Upload 12 files

.dockerignore

@@ -0,0 +1,10 @@
+.env
+__pycache__/
+*.pyc
+data/
+notebooks/
+test_*.py
+diag_output*.txt
+.git/
+.gitignore
+venv/

.env

@@ -0,0 +1,2 @@
+
+GEMINI_API_KEY=AIzaSyDqLnQkZpNuciaGWLl3yzwVHxxhDXMzcpU

.gitignore

@@ -0,0 +1,100 @@
+# Python
+__pycache__/
+*.py[codz]
+*$py.class
+*.so
+.Python
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Django / Flask / Scrapy
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+instance/
+.webassets-cache
+.scrapy
+
+# Notebooks
+.ipynb_checkpoints
+
+# Environments & Secrets
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+vertex_config.json
+secrets.toml
+*.json
+
+# Large Model Files (Upload to HF directly)
+legal_bert_finetuned_risk/
+*.safetensors
+*.bin
+*.h5
+
+# OS Files
+.DS_Store
+Thumbs.db
+
+# IDEs
+.vscode/
+.idea/
+.spyderproject
+.spyproject
+
+# Diagnostic/Log Files
+diag_output*.txt
+
+# Cursor / AI
+.cursorignore
+.cursorindexingignore
+__marimo__
+.abstra/
+.mypy_cache/
+.ruff_cache/

Dockerfile

@@ -1,20 +1,27 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Use a Python slim image to keep it lightweight
+FROM python:3.10-slim
+
+# Install system dependencies for OCR and PDF processing
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install
+# Note: We use --no-cache-dir to keep the image small
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Expose Streamlit port
+EXPOSE 8501
+
+# Command to run the application
+# We use --server.address=0.0.0.0 for Cloud Run/Container compatibility
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 khushshah103
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,19 +1,19 @@
----
-title: LegalAi
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+---
+title: LegalAI Analyzer
+emoji: ⚖️
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 8501
+pinned: false
+---
+
+# LegalAI - AI-powered Contract Intelligence Platform
+AI-powered contract intelligence platform for automated contract review, structured summaries, risk detection and legal entity extraction. Features also include multi-document vendor comparison, conversational document chat and compliance auditing across major industry frameworks.
+
+## 🚀 Features
+Professional AI-powered contract review, structured summaries, risk detection, and legal entity extraction.
+
+## 🛠️ Local Setup
+1. `pip install -r requirements.txt`
+2. `streamlit run app.py`

api.py

@@ -0,0 +1,361 @@
+import os
+import torch
+import re
+import json
+import time
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from transformers import pipeline
+from google import genai
+from dotenv import load_dotenv
+
+from src.improved_extractor import ImprovedExtractor
+from src.rag_service import RAGService
+from io import BytesIO
+import config
+
+# Load environment variables
+load_dotenv()
+
+app = FastAPI(title="LegalAI API", version="1.0")
+
+# CORS for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global instances
+classifier = None
+client = None
+extractor = None
+rag = None
+
+def load_services():
+    global classifier, client, extractor, rag
+    
+    # 1. Risk Classifier
+    torch.manual_seed(42)
+    local_path = config.FINE_TUNED_MODEL_PATH
+    model_to_load = "nlpaueb/legal-bert-base-uncased"
+    if os.path.isdir(local_path) and os.path.exists(os.path.join(local_path, "config.json")):
+        model_to_load = local_path
+        
+    try:
+        classifier = pipeline(
+            "text-classification", 
+            model=model_to_load,
+            device=0 if torch.cuda.is_available() else -1,
+            model_kwargs={"low_cpu_mem_usage": True}
+        )
+        print(f"✅ API: Classifier loaded using {model_to_load}")
+    except Exception as e:
+        print(f"⚠️ API: Classifier failed: {e}")
+
+    # 2. Gemini LLM (Centralized)
+    if config.GEMINI_API_KEY:
+        try:
+            client = genai.Client(api_key=config.GEMINI_API_KEY)
+            print("✅ API: Gemini Client initialized")
+        except Exception as e:
+            print(f"⚠️ API: Gemini Client failed: {e}")
+    else:
+        # Fallback to Vertex if config exists but key doesn't
+        vertex_json = os.path.join(config.BASE_DIR, "vertex_config.json")
+        if os.path.exists(vertex_json):
+            try:
+                with open(vertex_json, "r") as f:
+                    v_config = json.load(f)
+                os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = os.path.abspath(vertex_json)
+                client = genai.Client(vertexai=True, project=v_config.get("project_id"), location="us-central1")
+                print("✅ API: Vertex AI Client initialized")
+            except Exception as e:
+                print(f"⚠️ API: Vertex AI failed: {e}")
+
+    # 3. Extractor
+    extractor = ImprovedExtractor()
+
+    # 4. RAG Service
+    rag = RAGService()
+    try:
+        rag_data_path = os.path.join(config.BASE_DIR, "data", "text")
+        if os.path.exists(rag_data_path):
+            rag.load_documents(rag_data_path)
+            print(f"✅ API: RAG loaded from {rag_data_path}")
+    except Exception as e:
+        print(f"⚠️ API: RAG loading failed: {e}")
+
+@app.on_event("startup")
+async def startup_event():
+    load_services()
+
+
+# ====================================================================
+# Helper: Call Gemini with standardized fallback
+# ====================================================================
+def call_gemini(prompt, preferred_model=None):
+    """Single helper for all Gemini calls. Retries with backoff and model fallback."""
+    if not client:
+        print("❌ API: No Gemini client available")
+        return None
+    
+    # Use preferred model if provided, else fallback to config list
+    models_to_try = [preferred_model] if preferred_model else config.MODEL_FALLBACKS
+    
+    for attempt in range(2): # 2 main retry loops
+        for model_id in models_to_try:
+            try:
+                # Basic generation
+                response = client.models.generate_content(model=model_id, contents=prompt)
+                if response and response.text:
+                    return response.text
+                else:
+                    print(f"⚠️ API: {model_id} returned empty response")
+            except Exception as e:
+                err = str(e).upper()
+                # Handle Rate Limits
+                if "429" in err or "QUOTA" in err or "LIMIT" in err:
+                    wait = 10 * (attempt + 1)
+                    print(f"⏳ API: Rate limited on {model_id}. Waiting {wait}s...")
+                    time.sleep(wait)
+                    break # Try next model or next attempt
+                # Handle Model Not Found (404)
+                elif "404" in err or "NOT FOUND" in err:
+                    print(f"❌ API: Model {model_id} NOT FOUND. Skipping.")
+                    continue # Try next model in list
+                else:
+                    print(f"❌ API: {model_id} failed: {e}")
+                    continue
+    return None
+
+
+# ====================================================================
+# Utility
+# ====================================================================
+def clean_text(text):
+    if not text:
+        return ""
+    text = re.sub(r'_{2,}', '', text)
+    text = re.sub(r'\{.*?\}', '', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    text = re.sub(r' +', ' ', text)
+    text = re.sub(r'Page \d+', '', text)
+    return text.strip()
+
+
+# ====================================================================
+# API Models
+# ====================================================================
+from pydantic import BaseModel
+from typing import List, Optional
+
+class TextRequest(BaseModel):
+    text: str
+
+class ChatRequest(BaseModel):
+    text: str
+    history: List[dict]
+    prompt: str
+
+class ComplianceRequest(BaseModel):
+    text: str
+    framework: str
+
+class SearchRequest(BaseModel):
+    query: str
+
+
+# ====================================================================
+# ENDPOINTS (each defined ONCE, clean and simple)
+# ====================================================================
+
+@app.get("/api/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "services": {
+            "classifier": classifier is not None,
+            "gemini": client is not None,
+            "rag": rag is not None
+        }
+    }
+
+
+@app.post("/api/analyze/extract")
+async def extract_document(file: UploadFile = File(...)):
+    if not file:
+        raise HTTPException(status_code=400, detail="No file provided")
+    temp_path = f"temp_{file.filename}"
+    try:
+        content = await file.read()
+        with open(temp_path, "wb") as f:
+            f.write(content)
+        raw_text = extractor.extract_text(temp_path)
+        cleaned_text = clean_text(raw_text)
+        return {"raw_text": raw_text, "cleaned_text": cleaned_text}
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+
+@app.post("/api/analyze/summary")
+async def analyze_summary(req: TextRequest):
+    prompt = f"""
+    Act as a Senior Legal Counsel. Provide a professional, detailed, and structured executive summary.
+    Use bold headings for: Purpose & Overview, Key Obligations, Payment & Compensation, Term & Termination, and Liability & Risk.
+    
+    Contract Text:
+    {req.text[:60000]}
+    """
+    result = call_gemini(prompt)
+    return {"summary": result or "⚠️ Summary generation failed."}
+
+
+@app.post("/api/analyze/entities")
+async def analyze_entities(req: TextRequest):
+    # Smart sampling: first 20k + last 15k to capture preamble AND signature blocks
+    first_part = req.text[:20000]
+    last_part = req.text[-15000:] if len(req.text) > 20000 else ""
+    sample = first_part + "\n\n--- END OF DOCUMENT ---\n\n" + last_part
+    
+    prompt = f"""
+    Act as a Legal Clerk. Extract core legal entities from this contract.
+    
+    CRITICAL RULES:
+    - Do NOT extract placeholders like [PROVIDER LEGAL NAME] or [CUSTOMER].
+    - Check the signature block at the end for actual names.
+    - If only placeholders exist, write "NOT SPECIFIED (Generic Template)".
+    
+    Extract:
+    1. Contracting Parties (Full legal names)
+    2. Effective Date
+    3. Governing Law
+    4. Total Contract Value
+    
+    Contract Text:
+    {sample}
+    """
+    result = call_gemini(prompt)
+    return {"entities_text": result or "⚠️ Entity extraction failed."}
+
+
+@app.post("/api/analyze/scam")
+async def analyze_scam(req: TextRequest):
+    prompt = f"""
+    Act as a Senior Contract Auditor. Scan for predatory, hidden, or highly imbalanced clauses.
+    Focus on: IP transfers, uncapped liability, sneaky auto-renewals, hidden exit fees.
+    
+    If found, respond: FLAGGED: [1-sentence explanation]
+    If safe, respond: SAFE
+    
+    Contract Text:
+    {req.text[:60000]}
+    """
+    result = call_gemini(prompt)
+    if result and "FLAGGED:" in result:
+        return {"scam_warning": result.split("FLAGGED:")[1].strip()}
+    return {"scam_warning": None}
+
+
+@app.post("/api/analyze/risk")
+async def analyze_risk(req: TextRequest):
+    if not classifier:
+        return {"label": "N/A", "score": 0.0, "description": ""}
+    try:
+        cleaned = clean_text(req.text)
+        result = classifier(cleaned[:512])[0]
+        label_id = result['label']
+        mapping = {
+            "LABEL_0": ("High Risk", "Critical issues found. Requires legal review."), 
+            "LABEL_1": ("Low Risk", "Standard safe clauses. Low legal overhead."), 
+            "LABEL_2": ("Medium Risk", "Minor deviations found. Proceed with caution.")
+        }
+        name, desc = mapping.get(label_id, (label_id, ""))
+        return {"label": name, "score": result['score'], "description": desc}
+    except Exception as e:
+        return {"label": f"Error: {e}", "score": 0.0, "description": ""}
+
+
+@app.post("/api/analyze/compliance")
+async def analyze_compliance(req: ComplianceRequest):
+    prompt = f"""
+    Act as an expert compliance auditor. Check this contract against: '{req.framework}'.
+    
+    Evaluate 4-5 critical requirements. For each, give Pass (✅) or Fail (❌) with a 1-sentence reason.
+    Format as a clean Markdown list.
+    
+    Contract Text:
+    {req.text[:60000]}
+    """
+    result = call_gemini(prompt)
+    return {"result": result or "⚠️ Compliance check failed."}
+
+
+@app.post("/api/analyze/compare")
+async def analyze_compare(req: TextRequest):
+    prompt = f"""
+    Extract the following strictly as a JSON object with EXACTLY these keys:
+    "Vendor_Name", "Total_Pricing", "Term_Duration", "Liability_Cap", "Termination_Notice"
+    
+    If a field is missing, use "Not Specified".
+    Do NOT output any markdown blocks. ONLY output the raw JSON object.
+
+    Contract text:
+    {req.text[:15000]}
+    """
+    result = call_gemini(prompt)
+    if result:
+        try:
+            resp_text = result.strip()
+            if resp_text.startswith("```json"):
+                resp_text = resp_text[7:]
+            if resp_text.endswith("```"):
+                resp_text = resp_text[:-3]
+            data = json.loads(resp_text)
+            return {"data": data}
+        except Exception:
+            pass
+    return {"data": None}
+
+
+@app.post("/api/chat")
+async def chat_document(req: ChatRequest):
+    history_text = ""
+    for msg in req.history:
+        role_str = "User" if msg["role"] == "user" else "Assistant"
+        history_text += f"{role_str}: {msg['content']}\n"
+        
+    prompt = f"""
+    You are a helpful legal assistant. Answer based ONLY on the contract text.
+    If the answer is not in the text, say "I cannot find the answer to this in the document."
+    
+    Contract Text:
+    {req.text[:100000]}
+    
+    Conversation History:
+    {history_text}
+    
+    Latest Question: {req.prompt}
+    """
+    result = call_gemini(prompt)
+    return {"answer": result or "Failed to generate answer."}
+
+
+@app.post("/api/library/search")
+async def library_search(req: SearchRequest):
+    if not rag:
+        return {"error": "RAG service not loaded"}
+    try:
+        relevant_chunks = rag.query(req.query, top_k=3)
+        answer = rag.generate_answer(req.query, relevant_chunks, client)
+        refs = [{"file": res["metadata"]["file"], "text": res["text"]} for res in relevant_chunks]
+        return {"answer": answer, "references": refs}
+    except Exception as e:
+        return {"error": f"Search failed: {e}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app.py

@@ -0,0 +1,605 @@
+import streamlit as st
+import os
+import torch
+from transformers import pipeline
+from src.improved_extractor import ImprovedExtractor
+from src.rag_service import RAGService
+import re
+import json
+import time
+import pandas as pd
+from google import genai
+from dotenv import load_dotenv
+import config
+
+# Load environment variables
+load_dotenv()
+
+# --- Page Configuration ---
+st.set_page_config(
+    page_title=config.APP_NAME,
+    page_icon="⚖️",
+    layout="wide",
+)
+
+# Initialize Session State Globally with robust checks
+def init_session_state():
+    if "messages" not in st.session_state:
+        st.session_state["messages"] = []
+    if "current_file" not in st.session_state:
+        st.session_state["current_file"] = None
+    if "file_data" not in st.session_state:
+        st.session_state["file_data"] = {}
+    if "models_loaded" not in st.session_state:
+        st.session_state["models_loaded"] = False
+
+init_session_state()
+
+# --- Styling ---
+st.markdown("""
+    <style>
+    .main {
+        background-color: #f5f7f9;
+    }
+    .stButton>button {
+        width: 100%;
+        border-radius: 5px;
+        height: 3em;
+        background-color: #1e3a8a;
+        color: white;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+# --- Global Services ---
+@st.cache_resource(show_spinner=False)
+def get_classifier(version=1):
+    # Fix seed for consistent random head initialization (if fine-tuned path is missing)
+    torch.manual_seed(42)
+    
+    # Check for local fine-tuned model from the user's notebook progress
+    local_path = config.FINE_TUNED_MODEL_PATH
+    model_to_load = "nlpaueb/legal-bert-base-uncased"
+    
+    if os.path.isdir(local_path) and os.path.exists(os.path.join(local_path, "config.json")):
+        model_to_load = local_path
+        print(f"✅ Loading local fine-tuned model: {local_path}")
+    else:
+        print(f"ℹ️ Falling back to base Legal-BERT (random accuracy for risk).")
+        
+    return pipeline(
+        "text-classification", 
+        model=model_to_load,
+        device=0 if torch.cuda.is_available() else -1,
+        model_kwargs={"low_cpu_mem_usage": True}
+    )
+
+@st.cache_resource
+def get_gemini_client():
+    # Centralized client initialization
+    if config.GEMINI_API_KEY:
+        try:
+            c = genai.Client(api_key=config.GEMINI_API_KEY)
+            print("✅ Initialized Gemini Client")
+            return c
+        except Exception as e:
+            print(f"❌ Gemini Client init failed: {e}")
+    
+    # Fallback to Vertex
+    vertex_json = os.path.join(config.BASE_DIR, "vertex_config.json")
+    if os.path.exists(vertex_json):
+        try:
+            with open(vertex_json, "r") as f:
+                v_config = json.load(f)
+            os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = os.path.abspath(vertex_json)
+            c = genai.Client(
+                vertexai=True,
+                project=v_config.get("project_id"),
+                location="us-central1"
+            )
+            print("✅ Initialized Vertex AI Client")
+            return c
+        except Exception as e:
+            print(f"⚠️ Vertex AI failed: {e}")
+    
+    return None
+
+# Removed BERT-based get_ner to save RAM. Using Gemini for Entity Extraction.
+
+@st.cache_resource
+def get_rag():
+    r = RAGService()
+    try:
+        rag_data_path = os.path.join(config.BASE_DIR, "data", "text")
+        if os.path.exists(rag_data_path):
+            r.load_documents(rag_data_path)
+    except Exception as e:
+        print(f"Error loading RAG: {e}")
+    return r
+
+# --- UI Loader (Non-Cached) ---
+def load_models(progress_bar=None, status_text=None):
+    """
+    Orchestrates the loading of all models with UI progress feedback.
+    The individual load functions are cached, so this function run fast after the first time.
+    """
+    # 1. Risk Classifier
+    if status_text: status_text.text("Loading Risk Classifier (BERT)...")
+    if progress_bar: progress_bar.progress(20)
+    classifier = get_classifier()
+
+    # 2. Gemini LLM (for Summarization, RAG & NER)
+    if status_text: status_text.text("Connecting to Gemini AI...")
+    if progress_bar: progress_bar.progress(50)
+    client = get_gemini_client()
+
+    # 3. RAG Service
+    if status_text: status_text.text("Indexing Document Library...")
+    if progress_bar: progress_bar.progress(90)
+    rag_service = get_rag()
+
+    return {
+        "classifier": classifier,
+        "client": client,
+        "extractor": ImprovedExtractor(),
+        "rag": rag_service
+    }
+
+# --- Initial Setup & Startup Sequence ---
+def startup_sequence():
+    """
+    Shows a splash screen only on the first run of the session.
+    """
+    if not st.session_state.get('models_loaded'):
+        placeholder = st.empty()
+        with placeholder.container():
+            st.markdown(f"""
+                <div style="text-align: center; padding: 50px;">
+                    <h1 style="font-size: 3em;">⚖️ {config.APP_NAME}</h1>
+                    <p style="font-size: 1.2em; color: #666;">Warming up the AI engine... This takes about 30-45 seconds on first boot.</p>
+                </div>
+            """, unsafe_allow_html=True)
+            
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            # This triggers the individual cached loads
+            load_models(progress_bar, status_text)
+            
+            progress_bar.progress(100)
+            status_text.text("System ready!")
+            st.session_state['models_loaded'] = True
+            time.sleep(1)
+        placeholder.empty()
+
+# Run startup
+startup_sequence()
+models = load_models() # Returns instantly if already cached
+classifier = models["classifier"]
+client = models["client"]
+extractor = models["extractor"]
+rag = models["rag"]
+
+def call_gemini(prompt, preferred_model=None):
+    """Single helper for all Gemini calls. Retries with backoff and model fallback."""
+    if not client:
+        return None
+    
+    models_to_try = [preferred_model] if preferred_model else config.MODEL_FALLBACKS
+    
+    for attempt in range(2):
+        for model_id in models_to_try:
+            try:
+                response = client.models.generate_content(model=model_id, contents=prompt)
+                if response and response.text:
+                    return response.text
+            except Exception as e:
+                err = str(e).upper()
+                if "429" in err or "QUOTA" in err or "LIMIT" in err:
+                    if attempt < 1:
+                        wait = 10 * (attempt + 1)
+                        time.sleep(wait)
+                        break
+                    continue
+                elif "404" in err or "NOT FOUND" in err:
+                    continue
+                else:
+                    continue
+    return None
+
+def get_summary(text):
+    prompt = f"""
+    Act as a Senior Legal Counsel with 20 years of experience in contract law. 
+    Review the provided legal contract and generate a high-level, professional executive summary.
+
+    STRUCTURE YOUR RESPONSE AS FOLLOWS:
+    1. **Executive Overview**: High-level purpose of the agreement.
+    2. **Key Financial Terms**: Payment schedules, amounts, and late fees.
+    3. **Operational Obligations**: What must each party actually DO?
+    4. **Termination & Exit**: How do parties leave, and what are the notice periods?
+    5. **Critical Liability & Risk**: Indemnities, liability caps, and any "one-sided" clauses.
+    6. **Counsel's Recommendation**: A 2-3 sentence professional verdict on the contract's fairness.
+
+    INSTRUCTIONS:
+    - Use a professional, objective, and analytical tone.
+    - If you find highly imbalanced or "predatory" clauses, mention them under "Critical Liability & Risk" in a factual, legal manner rather than using alarmist language.
+    - Focus on specificities (dates, percentages, dollar amounts).
+    - Ensure the summary is readable but dense with information.
+    
+    Contract Text:
+    {text[:config.MAX_CHAR_LIMIT]}
+    """
+    result = call_gemini(prompt)
+    return result or "⚠️ Summary generation failed."
+
+def get_entities(text):
+    """Smart sampling: first 20k + last 15k chars to capture preamble AND signature blocks."""
+    first_part = text[:20000]
+    last_part = text[-15000:] if len(text) > 20000 else ""
+    sample = first_part + "\n\n--- END OF DOCUMENT ---\n\n" + last_part
+    
+    prompt = f"""
+    Act as a Legal Clerk. Extract the following core entities from the contract.
+    
+    CRITICAL ACCURACY RULES:
+    1. DO NOT extract generic placeholders like "[PROVIDER LEGAL NAME]", "[CUSTOMER]", or placeholders in curly brackets.
+    2. Examine BOTH the introductory paragraph AND the signature blocks at the end for ACTUAL company names.
+    3. If a field only contains a placeholder, write "NOT SPECIFIED (Generic Template Detected)".
+    
+    IDENTIFY:
+    1. Contracting Parties (Full legal names of all parties involved)
+    2. Effective Date (The start date of the agreement)
+    3. Governing Law (Which state/country's laws apply)
+    4. Total Contract Value (Specific monetary amount or fee structure)
+    
+    Contract Text:
+    {sample}
+    """
+    result = call_gemini(prompt)
+    return result or "⚠️ Entity extraction failed."
+
+def check_unethical_clauses(text):
+    """Scans full document (60k chars) for predatory clauses."""
+    prompt = f"""
+    Act as a Senior Contract Auditor. Scan for predatory, hidden, or highly imbalanced clauses.
+    Focus on: IP transfers, uncapped liability, sneaky auto-renewals, hidden exit fees.
+    
+    If found, respond: FLAGGED: [1-sentence explanation]
+    If safe, respond: SAFE
+    
+    Contract Text:
+    {text[:60000]}
+    """
+    result = call_gemini(prompt)
+    if result and "FLAGGED:" in result:
+        return result.split("FLAGGED:")[1].strip()
+    return None
+
+
+def get_risk(text):
+    if not classifier:
+        return "N/A", 0.0, ""
+    try:
+        cleaned = clean_text(text)
+        # Use first 512 tokens as BERT limit
+        result = classifier(cleaned[:512])[0]
+        label_id = result['label']
+        mapping = {
+            "LABEL_0": ("High Risk", "Critical issues found. Requires legal review."), 
+            "LABEL_1": ("Low Risk", "Standard safe clauses. Low legal overhead."), 
+            "LABEL_2": ("Medium Risk", "Minor deviations found. Proceed with caution.")
+        }
+        name, desc = mapping.get(label_id, (label_id, ""))
+        return name, result['score'], desc
+    except Exception as e:
+        return f"Error: {e}", 0.0, ""
+
+
+
+def run_compliance_check(text, framework):
+    """Runs compliance audit against the full document (60k chars)."""
+    prompt = f"""
+    Act as an expert compliance auditor. Check this contract against: '{framework}'.
+    
+    Evaluate 4-5 critical requirements. For each, give Pass (✅) or Fail (❌) with 1-sentence reason.
+    Format as a clean Markdown list.
+    
+    Contract Text:
+    {text[:60000]}
+    """
+    result = call_gemini(prompt)
+    return result or "⚠️ Compliance check failed."
+
+def clean_text(text):
+    """
+    Cleans raw document text by removing noise like placeholders and extra whitespace.
+    """
+    if not text:
+        return ""
+    # Remove long sequences of underscores (placeholders)
+    text = re.sub(r'_{2,}', '', text)
+    # Remove curly bracket placeholders e.g. {services/project name}
+    text = re.sub(r'\{.*?\}', '', text)
+    # Remove multiple newlines
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    # Remove multiple spaces
+    text = re.sub(r' +', ' ', text)
+    # Remove "Page X" noise
+    text = re.sub(r'Page \d+', '', text)
+    return text.strip()
+def get_comparison_data(text):
+    prompt = f"""
+    Extract the following strictly as a JSON object with EXACTLY these keys:
+    "Vendor_Name", "Total_Pricing", "Term_Duration", "Liability_Cap", "Termination_Notice"
+    
+    If a field is missing, use "Not Specified".
+    Do NOT output any markdown blocks. ONLY output the raw JSON object.
+
+    Contract text:
+    {text[:15000]}
+    """
+    result = call_gemini(prompt)
+    if result:
+        try:
+            resp_text = result.strip()
+            if resp_text.startswith("```json"):
+                resp_text = resp_text[7:]
+            if resp_text.endswith("```"):
+                resp_text = resp_text[:-3]
+            return json.loads(resp_text)
+        except Exception:
+            pass
+    return None
+
+# Check for model health
+is_fine_tuned = os.path.isdir("legal_bert_finetuned_risk")
+
+# --- Sidebar ---
+with st.sidebar:
+    st.image("https://cdn-icons-png.flaticon.com/512/2901/2901306.png", width=100)
+    st.title("Admin Panel")
+    st.info("Upload your legal contracts to begin automated analysis. Upload multiple files for vendor comparison.")
+    uploaded_files = st.file_uploader("Upload PDF Contract(s)", type=["pdf"], accept_multiple_files=True)
+
+# --- Header ---
+st.title("⚖️ Legal Document & Risk Analyzer")
+st.markdown("Automated intelligence for contract review, risk mitigation, and semantic search.")
+
+if not is_fine_tuned:
+    st.warning("⚠️ **Warning:** No fine-tuned model found in `./legal_bert_finetuned_risk`. The risk classification is currently using 'Base' weights and will be inaccurate. Please provide your trained model files for accurate assessment.")
+
+if uploaded_files:
+    if len(uploaded_files) == 1:
+        uploaded_file = uploaded_files[0]
+        # Check if a new file was uploaded to reset the cache
+        if st.session_state["current_file"] != uploaded_file.name:
+            st.session_state["current_file"] = uploaded_file.name
+            st.session_state["messages"] = [] # Reset chat
+            st.session_state["file_data"] = {} # Reset analytics cache
+
+        # Save uploaded file to temp path
+        with open(uploaded_file.name, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        
+        # Text Extraction
+        with st.spinner("Processing document..."):
+            raw_text = extractor.extract_text(uploaded_file.name)
+            cleaned_text = clean_text(raw_text)
+            
+        # Clean up temp file immediately so it doesn't clutter the folder
+        try:
+            os.remove(uploaded_file.name)
+        except OSError:
+            pass
+
+        # Phase 1: Summary & Scam Scan
+        col_sum, col_risk = st.columns([2, 1])
+        
+        with col_sum:
+            st.subheader("🤖 AI Summary")
+            if "summary" not in st.session_state["file_data"]:
+                with st.spinner("Analyzing document with Gemini 2.5 Pro..."):
+                    st.session_state["file_data"]["summary"] = get_summary(raw_text)
+            st.markdown(st.session_state["file_data"]["summary"])
+
+            # Note: Scam/Ethical check is still performed but information is now integrated into the Risk and Summary sections
+            if "scam_warning" not in st.session_state["file_data"]:
+                time.sleep(2)  # Rate limit protection
+                with st.spinner("Auditing clauses..."):
+                    st.session_state["file_data"]["scam_warning"] = check_unethical_clauses(raw_text)
+
+        with col_risk:
+            st.subheader("⚖️ Risk Profile")
+            if "risk" not in st.session_state["file_data"]:
+                with st.spinner("Analyzing risk..."):
+                    st.session_state["file_data"]["risk"] = get_risk(raw_text)
+            
+            label, score, description = st.session_state["file_data"]["risk"]
+            color = "#16a34a" # Low
+            if "Medium" in label: color = "#f59e0b"
+            if "High" in label: color = "#ef4444"
+            
+            st.markdown(f"""
+                <div style="background-color: {color}; padding: 15px; border-radius: 8px; color: white; text-align: center;">
+                    <h2 style="color: white; margin: 0; font-size: 1.5em;">{label}</h2>
+                </div>
+                """, unsafe_allow_html=True)
+            if description:
+                st.markdown(f"**Actionable Insight:** {description}")
+            if not is_fine_tuned:
+                st.caption("🚨 Results are uncalibrated (Base Model).")
+                    
+        # Phase 2: Professional Entity Extraction
+        st.divider()
+        st.subheader("🔍 Key Legal Entities")
+        if "entities" not in st.session_state["file_data"]:
+            time.sleep(2)  # Rate limit protection
+            with st.spinner("Extracting parties with AI..."):
+                entities_text = get_entities(raw_text)  # Use raw_text for full context
+                st.session_state["file_data"]["entities"] = entities_text if entities_text else "No entities detected."
+        
+        st.info(st.session_state["file_data"]["entities"])
+
+
+        # Phase 2.5: Automated Compliance Checklists
+        st.divider()
+        st.subheader("🛡️ Compliance & Audit")
+        st.markdown("Run automated checks against strict regulatory and industry frameworks.")
+        
+        frameworks = [
+            "Select a framework to audit...",
+            "General Data Protection Regulation (GDPR)",
+            "Standard SaaS Agreement Best Practices",
+            "Independent Contractor / Freelance Standard"
+        ]
+        
+        selected_framework = st.selectbox("Select Compliance Framework:", frameworks)
+        
+        if selected_framework != "Select a framework to audit...":
+            cache_key = f"compliance_{selected_framework}"
+            
+            if cache_key not in st.session_state["file_data"]:
+                with st.spinner(f"Running {selected_framework} audit..."):
+                    if not client:
+                        st.warning("Gemini AI is not connected.")
+                    else:
+                        st.session_state["file_data"][cache_key] = run_compliance_check(cleaned_text, selected_framework)
+            
+            if st.session_state["file_data"].get(cache_key):
+                st.info(st.session_state["file_data"][cache_key])
+            elif client:
+                st.error("Audit failed to generate.")
+
+        # Phase 3: Interactive Chatbot
+        st.divider()
+        st.subheader("💬 Chat with Document")
+        
+        if not client:
+            st.warning("⚠️ **Gemini API Key Missing:** Interactive chat is disabled.")
+        else:
+            # Display chat messages from history on app rerun
+            for message in st.session_state.messages:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+
+            # Accept user input
+            if prompt := st.chat_input("Ask a question about this contract (e.g., 'What are the termination conditions?')..."):
+                # Add user message to chat history
+                st.session_state.messages.append({"role": "user", "content": prompt})
+                # Display user message in chat message container
+                with st.chat_message("user"):
+                    st.markdown(prompt)
+
+                # Display assistant response in chat message container
+                with st.chat_message("assistant"):
+                    message_placeholder = st.empty()
+                    with st.spinner("Analyzing document and generating answer..."):
+                        context = cleaned_text[:100000] # Safe limit for large documents
+                        
+                        # Build conversation history for the prompt
+                        history_text = ""
+                        for msg in st.session_state.messages[:-1]: # exclude the current prompt
+                            role_str = "User" if msg["role"] == "user" else "Assistant"
+                            history_text += f"{role_str}: {msg['content']}\n"
+                            
+                        full_prompt = f"""
+                        You are a helpful legal assistant. Answer the user's latest question based ONLY on the following contract text and the conversation history so far. 
+                        If the answer is not in the text, say "I cannot find the answer to this in the document."
+                        
+                        Contract Text:
+                        {context}
+                        
+                        Conversation History:
+                        {history_text}
+                        
+                        Latest Question: {prompt}
+                        """
+                        
+                        answer = call_gemini(full_prompt)
+                        if not answer:
+                            answer = "Failed to generate answer. Please try again."
+                        message_placeholder.markdown(answer)
+                        
+                    # Add assistant response to chat history
+                    st.session_state.messages.append({"role": "assistant", "content": answer})
+    else:
+        # Multi-Document Vendor Comparison Mode
+        st.header("📊 Multi-Document Vendor Comparison Matrix")
+        st.markdown("Comparing key terms across multiple uploaded contracts.")
+        
+        comparison_results = []
+        
+        # We use a progress bar to show extraction status
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        for i, file in enumerate(uploaded_files):
+            status_text.text(f"Extracting data from {file.name} ({i+1}/{len(uploaded_files)})...")
+            # Save temp
+            with open(file.name, "wb") as f:
+                f.write(file.getbuffer())
+            
+            # Extract
+            raw_text = extractor.extract_text(file.name)
+            cleaned_text = clean_text(raw_text)
+            
+            # Clean up temp file immediately
+            try:
+                os.remove(file.name)
+            except OSError:
+                pass
+            
+            # Get structured data
+            data = get_comparison_data(cleaned_text)
+            if data:
+                data["Filename"] = file.name
+                comparison_results.append(data)
+            else:
+                comparison_results.append({
+                    "Filename": file.name,
+                    "Vendor_Name": "Extraction Failed",
+                    "Total_Pricing": "N/A",
+                    "Term_Duration": "N/A",
+                    "Liability_Cap": "N/A",
+                    "Termination_Notice": "N/A"
+                })
+            
+            progress_bar.progress((i + 1) / len(uploaded_files))
+            
+        status_text.text("Extraction Complete!")
+        
+        if comparison_results:
+            st.divider()
+            df = pd.DataFrame(comparison_results)
+            # Reorder columns to put Filename first
+            cols = ["Filename", "Vendor_Name", "Total_Pricing", "Term_Duration", "Liability_Cap", "Termination_Notice"]
+            df = df[[c for c in cols if c in df.columns]]
+            
+            st.dataframe(df, use_container_width=True, hide_index=True)
+            
+            st.success("Comparison Matrix generated successfully! You can download this table via the download button inside the table view.")
+
+else:
+    st.warning("Please upload a PDF document in the sidebar to start analysis.")
+    st.info("💡 **Tip:** You can use the Library Search below to query your repository of legal documents.")
+    
+    st.divider()
+    st.subheader("📚 Global Library Search")
+    lib_query = st.text_input("Identify patterns across your entire library:")
+    if lib_query:
+        with st.spinner("Searching library..."):
+            relevant_chunks = rag.query(lib_query, top_k=3)
+            answer = rag.generate_answer(lib_query, relevant_chunks, client)
+
+            
+            st.markdown("### 🤖 Synthesized Knowledge")
+            st.success(answer)
+            
+            st.markdown("#### Document References")
+            for i, res in enumerate(relevant_chunks):
+                st.markdown(f"**{i+1}. From {res['metadata']['file']}:**")
+                st.caption(res['text'])
+
+# --- Footer ---
+st.divider()
+st.caption("LegalAI Analyzer v1.2 | Powered by Legal-BERT & T5")

config.py

@@ -0,0 +1,34 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# --- Gemini Configuration ---
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+# Verified models based on diagnostic output
+# Using 2.0-flash as primary for speed, pro-latest for complex tasks
+PRIMARY_MODEL = "gemini-2.0-flash"
+COMPLEX_MODEL = "gemini-pro-latest"
+
+# Fallback chain for reliability
+MODEL_FALLBACKS = [
+    "gemini-2.0-flash",
+    "gemini-flash-latest",
+    "gemini-pro-latest",
+    "gemini-2.5-flash"  # Experimental but available
+]
+
+# --- App Settings ---
+APP_NAME = "LegalAI Portable"
+MAX_CHAR_LIMIT = 60000  # Streamlit/API context window limit
+ENTITY_EXTRACTION_CHARS = 35000  # Smart sampling limit
+
+# --- Paths ---
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+FINE_TUNED_MODEL_PATH = os.path.join(BASE_DIR, "legal_bert_finetuned_risk")
+
+def is_model_loaded():
+    return GEMINI_API_KEY is not None and GEMINI_API_KEY != ""

train_model.py

@@ -0,0 +1,141 @@
+import pandas as pd
+import numpy as np
+import torch
+import os
+from datasets import Dataset, DatasetDict, ClassLabel, Features
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    TrainingArguments,
+    Trainer,
+    pipeline
+)
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+
+# --- 1. Load Dataset ---
+csv_path = os.path.join("data", "legal_contract_clauses.csv")
+if not os.path.exists(csv_path):
+    print(f"Error: '{csv_path}' not found locally.")
+    import sys
+    sys.exit(1)
+
+print("Step 1: Loading dataset...")
+df = pd.read_csv(csv_path)
+TEXT_COLUMN = "clause_text"
+LABEL_COLUMN = "risk_level"
+
+# --- 2. Create Label Mappings ---
+print("Step 2: Creating label mappings...")
+labels = df[LABEL_COLUMN].unique()
+labels.sort() 
+label2id = {label: i for i, label in enumerate(labels)}
+id2label = {i: label for i, label in enumerate(labels)}
+num_labels = len(labels)
+df['label'] = df[LABEL_COLUMN].map(label2id)
+
+# --- 3. Convert to Hugging Face Dataset ---
+print("Step 3: Converting to Hugging Face Dataset...")
+dataset = Dataset.from_pandas(df)
+
+print("Step 3a: Casting 'label' column to ClassLabel for stratification...")
+label_names_in_order = [id2label[i] for i in range(num_labels)]
+class_label_feature = ClassLabel(names=label_names_in_order)
+dataset = dataset.cast_column("label", class_label_feature)
+
+print("Step 3b: Splitting dataset...")
+train_test_split = dataset.train_test_split(test_size=0.2, seed=42, stratify_by_column="label")
+dataset_dict = DatasetDict({
+    'train': train_test_split['train'],
+    'test': train_test_split['test']
+})
+print(f"Training data: {len(dataset_dict['train'])} examples")
+print(f"Test data: {len(dataset_dict['test'])} examples")
+
+# --- 4. Loading Model ---
+print("\nStep 4: Loading model and tokenizer (nlpaueb/legal-bert-base-uncased)...")
+model_name = "nlpaueb/legal-bert-base-uncased"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForSequenceClassification.from_pretrained(
+    model_name,
+    num_labels=num_labels,
+    id2label=id2label,
+    label2id=label2id
+)
+
+# --- 5. Tokenizing ---
+print("\nStep 5: Tokenizing dataset...")
+def tokenize_function(examples):
+    return tokenizer(examples[TEXT_COLUMN], padding="max_length", truncation=True)
+
+tokenized_datasets = dataset_dict.map(tokenize_function, batched=True)
+columns_to_remove = [TEXT_COLUMN, LABEL_COLUMN]
+if "__index_level_0__" in tokenized_datasets["train"].column_names:
+    columns_to_remove.append("__index_level_0__")
+    
+tokenized_datasets = tokenized_datasets.remove_columns(columns_to_remove)
+tokenized_datasets.set_format("torch")
+print("Tokenization complete.")
+
+# --- 6. Metrics ---
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    acc = accuracy_score(labels, predictions)
+    f1 = f1_score(labels, predictions, average='weighted')
+    precision = precision_score(labels, predictions, average='weighted')
+    recall = recall_score(labels, predictions, average='weighted')
+    return {
+        "accuracy": acc,
+        "f1": f1,
+        "precision": precision,
+        "recall": recall
+    }
+
+# --- 7. Set Training Arguments & Train ---
+print("\nStep 6: Setting training arguments...")
+model_output_dir = "./legal_bert_finetuned_risk"
+training_args = TrainingArguments(
+    output_dir=model_output_dir,
+    learning_rate=2e-5,
+    per_device_train_batch_size=8, 
+    per_device_eval_batch_size=8,
+    num_train_epochs=3,
+    weight_decay=0.01,
+    load_best_model_at_end=True,
+    push_to_hub=False,
+    report_to="none",
+    eval_strategy="epoch",
+    save_strategy="epoch",
+)
+
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=tokenized_datasets["train"],
+    eval_dataset=tokenized_datasets["test"],
+    tokenizer=tokenizer,
+    compute_metrics=compute_metrics,
+)
+
+print("\nStep 7: Starting model training...")
+trainer.train()
+print("Training finished.")
+
+# --- 8. Save ---
+trainer.save_model(model_output_dir)
+tokenizer.save_pretrained(model_output_dir)
+print(f"Model saved to {model_output_dir}")
+
+# --- 9. Inference Test ---
+print("\nStep 8: Quick inference test...")
+risk_classifier = pipeline(
+    "text-classification", 
+    model=model_output_dir,
+    device=0 if torch.cuda.is_available() else -1 
+)
+
+test_clause = "Indemnification. The Contractor agrees to indemnify..."
+result = risk_classifier(test_clause, return_all_scores=True)
+print(f"Test Clause: '{test_clause}'")
+print(f"Prediction: {result}")
+                                                                

vertex_config.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "gen-lang-client-0878631680",
+  "private_key_id": "d6f22485bc2ec5a3ab7b79452d52122a8ba07bd9",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDMkeS+GQtVFKfG\n2EsznAHhPUlw6iwpLtFRQGjNyKQeMk7g/6CYXZPHNddUZIdWB7fpoVW4tvoUW9uH\nB+Dxs+fHBdqxzd20rsVPjnQlEhqWDwCbzICzn/j1gmaMfmFoR2d8GpZZk/WZLHUx\nqTVvJcelo3o+D2Y1JKcAPP6RSAsu2VF0MSzs0xYCpRokEMeTAaRh8LdIzwn4x2yO\nkG2FpgAvVwNu4C7yqPKqX/G6+47RpDOLE7XxrA7KJQ3Iyaq1izlB/AJv6TpJYCnJ\nF+y0+3ZtG+YWARJKryRYoIM6I3uYbT0hl4aSRrlyL/24BiOMHXMh8Ly/RrGPrlTD\nP2q3jGVhAgMBAAECggEAO+oc9ypJneUbUItH1zlBebEkAdysC3HJX4VATMkPfEKa\nxJ5J8GYz4nwb8X0yABnpnRUiEKQSsYTH0pAVq2TYJPvLdhkH7qPjaS4dSUA4piuF\nr5vhM/rOBUXoeAyJxetn3TrCP0EtBOw29NEMs916UEKFioijFDyEZvb2TiGuGM2J\noS9DCgjpy8khJlF8qRaJXYhRY4IZLOZ7/N6W0v0urBTlw6B678pK3vNNWTGetDUw\nNw9eunHJx0laMo7dPi0ZRKXVU46HjPh+UjO9JkVnSDtQ17nIi+uy1KQk3DM9zSNB\nLZ1S8OMNQ/w7nof5x49KtL4U/hkVBAJEZE+XIbrKEwKBgQD9rC4WCQMBvQQN8v/b\nT24F/Tn+OW3W0nD6MZk2D4T69uJIZoKg9wtcGPSfB/eWGbyrTUl45aYoPPzofAuA\nJtdYm8BBHom3Wl2c7hm7yD+9JriTovEPR2YTAPRb8WT9Uum5660cyeZrXdKUBw/k\nuwHfcu0h0q+QbE5Bx0HgFzd/swKBgQDOcmHfowPPQZh5Apxo6XmQsfro/wItQux6\nVYQPorp0nZc3QuK39TzD0w5EB0ln+PiePNk9Ka2QzksyKibwXDeK6+fFfLiD+VNe\nlhQ9ScQSc7g7aLKpUVgyBUhU3a94C3Fo6VcjD0UaEiGFXnaysjsz0NObuNWjoK/6\ndoMsg9ucmwKBgDQiV9Jlhb2suBGZ2GWdPHJ0qZ+K8/0LgPaajO9kXyMo7DaPAtfM\nDgSeiF/KxmKN5Y2bM7dqEyz/48Zv//kVgnqOgAOiIBGTu9uNv7ItJJReSd7lxP8r\n4FmVf6MJyISbrrdsLUbWY8m7HZUYonaSzH684ulpoHVhHPA94FcKzngrAoGAR5kh\n2pbFtnaQc791EWmPsKAZXf86+QmRzCemYmnUcqdJD3BSAuy5g0zKUMuaKMYPK4n8\n6ZpvyJ3TNHWsBYZl+Pcx7asArzykLlSsdkkECEY76da4x8IfbVGpsU0lEuQdE/6B\nKvabx5vsJj4JupXXtHPDP+mNpm8POTUq7yBX5OsCgYEAzDF3Wa5lLD9aDKfWjgYt\nGcXV+As1S+Lo0Vz4fspDZkwGGJk4Wfe2GIrPIbN+w2ybVlpFY9AskmlyEfveXT77\nKKjqhpdwOG2mN+ZQAbtga6I7x187uzihkMjgnuaEKBMWqSkxbIrDEy2YpJmyQvha\nY3bHgWSRtEwbysSaHCLbDhA=\n-----END PRIVATE KEY-----\n",
+  "client_email": "vertex-express@gen-lang-client-0878631680.iam.gserviceaccount.com",
+  "client_id": "117615514449694666186",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/vertex-express%40gen-lang-client-0878631680.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}