Upload 5 files

Dockerfile

@@ -0,0 +1,22 @@
+FROM PYTHON:3.13.3
+
+# Set the working directory
+WORKDIR /app
+# Copy the requirements file into the container
+COPY requirements.txt /app/requirements.txt
+# Install the required packages
+RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
+
+RUN useradd user
+
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+# Expose the port the app runs on
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0", "--port", "7680", "--reload"]

agent.py

@@ -0,0 +1,98 @@
+
+import os
+from typing import TypedDict, Annotated, List
+from langchain_core.messages import BaseMessage, ToolMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.tools import tool
+from langchain_groq import ChatGroq
+from langgraph.graph import StateGraph, END
+from langgraph.prebuilt import ToolNode
+from utils import process_documents
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# The retriever will be set at runtime from the FastAPI endpoint
+retriever_for_tool = None
+
+class AgentState(TypedDict):
+    messages: Annotated[List[BaseMessage], lambda x, y: x + y]
+    question: str
+    answer: str
+
+
+# This setter will be called from FastAPI to set the retriever for each request
+def set_retriever_for_tool(retriever):
+    global retriever_for_tool
+    retriever_for_tool = retriever
+
+@tool
+def retrieve_clauses(query: str) -> str:
+    """
+    Searches the policy document for relevant clauses based on a user's query.
+    Use this tool to find information within the document to answer a question.
+    """
+    global retriever_for_tool
+    if retriever_for_tool is None:
+        return "No retriever set. Please process the document first."
+    retrieved_docs = retriever_for_tool.invoke(query)
+    context = "\n\n---\n\n".join([doc.page_content for doc in retrieved_docs])
+    return context
+
+llm = ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", temperature=0, max_tokens=1024)
+tools = [retrieve_clauses]
+llm_with_tools = llm.bind_tools(tools)
+
+final_answer_prompt = ChatPromptTemplate.from_template(
+    """
+    You are an expert in policy and contract analysis. Your task is to answer the user's question in a complete, self-contained sentence, using only the provided context. If the context does not contain the answer, say so explicitly.
+
+    Always provide a full, context-rich answer, not just a short phrase or fragment. Your answer should be clear, precise, and directly address the user's question, restating key details as needed for clarity.
+
+    Do NOT answer with just a number, time period, or short phrase. Instead, write a full sentence that would make sense as a stand-alone answer in a JSON API response.
+
+    Context from the document:
+    ---
+    {context}
+    ---
+
+    User's Question: {question}
+
+    Your Answer:
+    """
+)
+string_parser = StrOutputParser()
+generation_chain = final_answer_prompt | llm | string_parser
+
+def call_model(state: AgentState):
+    messages = state["messages"]
+    response = llm_with_tools.invoke(messages)
+    return {"messages": [response]}
+
+def should_continue(state: AgentState):
+    if state["messages"][-1].tool_calls:
+        return "continue"
+    return "end"
+
+def generate_final_answer(state: AgentState):
+    question = state["question"]
+    context = ""
+    for msg in reversed(state["messages"]):
+        if isinstance(msg, ToolMessage):
+            context = msg.content
+            break
+    response = generation_chain.invoke({"context": context, "question": question})
+    return {"answer": response}
+
+workflow = StateGraph(AgentState)
+workflow.add_node("agent", call_model)
+workflow.add_node("action", ToolNode(tools))
+workflow.add_node("final_answer", generate_final_answer)
+
+workflow.set_entry_point("agent")
+workflow.add_conditional_edges("agent", should_continue, {"continue": "action", "end": "final_answer"})
+workflow.add_edge("action", "agent")
+workflow.add_edge("final_answer", END)
+
+agent_app = workflow.compile()

main.py

@@ -0,0 +1,56 @@
+import warnings
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+import os
+from typing import List
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, HttpUrl
+from dotenv import load_dotenv
+from agent import agent_app, set_retriever_for_tool
+
+load_dotenv()
+
+EXPECTED_TOKEN = os.getenv("BEARER_TOKEN")
+http_bearer_scheme = HTTPBearer()
+
+async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(http_bearer_scheme)):
+    if not credentials or credentials.scheme != "Bearer":
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication scheme.")
+    if credentials.credentials != EXPECTED_TOKEN:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token.")
+    return credentials.credentials
+
+class QueryRequest(BaseModel):
+    documents: HttpUrl
+    questions: List[str]
+
+class QueryResponse(BaseModel):
+    answers: List[str]
+
+app = FastAPI(
+    title="Intelligent Query-Retrieval System",
+    description="An API for processing documents and answering questions using a LangGraph ReAct agent.",
+    version="1.0.0"
+)
+
+@app.post("/hackrx/run", response_model=QueryResponse, tags=["Query"])
+async def run_submission(request: QueryRequest, token: str = Depends(verify_token)):
+    try:
+        # Process the document ONCE per request
+        from utils import process_documents
+        vector_store = process_documents(str(request.documents))
+        retriever = vector_store.as_retriever(search_kwargs={"k": 5})
+        set_retriever_for_tool(retriever)
+        responses = []
+        for question in request.questions:
+            final_state = agent_app.invoke({
+                "question": question,
+                "messages": [("user", question)]
+            })
+            answer_str = final_state.get("answer", "Error: Could not generate an answer.")
+            responses.append(answer_str)
+        return QueryResponse(answers=responses)
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))

requirements.txt

@@ -0,0 +1,18 @@
+python-dotenv
+fastapi
+uvicorn[standard]
+pydantic
+pinecone
+langchain-pinecone
+langchain-core
+langchain
+langchain-groq
+requests
+langchain-community
+ipykernel
+langgraph
+langchain-huggingface
+python-docx
+sentence-transformers
+pypdf
+tiktoken

utils.py

@@ -0,0 +1,86 @@
+import os
+import requests
+import tempfile
+from typing import List
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_pinecone import PineconeVectorStore
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+from langchain_core.tools import Tool
+from pinecone import Pinecone, ServerlessSpec
+from docx import Document as DocxDocument
+from dotenv import load_dotenv
+
+load_dotenv()
+
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
+PINECONE_INDEX_NAME = os.getenv("document-processor-index-1") or "policy-index"
+
+pc = Pinecone(api_key=PINECONE_API_KEY)
+embeddings_model = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+
+def download_file(url: str) -> str:
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        suffix = ".pdf" if ".pdf" in url else ".docx"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+            temp_file.write(response.content)
+            return temp_file.name
+    except requests.RequestException as e:
+        print(f"Error downloading file from {url}: {e}")
+        raise
+
+def load_docx_documents(file_path: str) -> List[Document]:
+    doc = DocxDocument(file_path)
+    full_text = [para.text for para in doc.paragraphs if para.text.strip()]
+    content = "\n".join(full_text)
+    return [Document(page_content=content)]
+
+def process_documents(document_url: str) -> PineconeVectorStore:
+    print("Starting data ingestion pipeline...")
+    temp_file_path = download_file(document_url)
+    
+    if temp_file_path.endswith(".pdf"):
+        loader = PyPDFLoader(temp_file_path)
+        docs = loader.load()
+    elif temp_file_path.endswith(".docx"):
+        docs = load_docx_documents(temp_file_path)
+    else:
+        raise ValueError("Unsupported document format provided.")
+    
+    print(f"Loaded {len(docs)} document pages.")
+
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    chunked_docs = text_splitter.split_documents(docs)
+    print(f"Split document into {len(chunked_docs)} chunks.")
+
+    if PINECONE_INDEX_NAME not in pc.list_indexes().names():
+        print(f"Creating new Pinecone index: {PINECONE_INDEX_NAME}")
+        pc.create_index(
+            name=PINECONE_INDEX_NAME,
+            dimension=384,
+            metric="cosine",
+            spec=ServerlessSpec(cloud="aws", region="us-east-1")
+        )
+
+    print("Upserting document chunks to Pinecone...")
+    vector_store = PineconeVectorStore.from_documents(
+        chunked_docs, embeddings_model, index_name=PINECONE_INDEX_NAME
+    )
+    print("Document processing complete.")
+    
+    os.remove(temp_file_path)
+    return vector_store
+
+def create_retriever_tool(vector_store: PineconeVectorStore) -> Tool:
+    retriever = vector_store.as_retriever(search_kwargs={"k": 5})
+    def retrieve_context(query: str) -> str:
+        retrieved_docs = retriever.invoke(query)
+        return "\n\n---\n\n".join([doc.page_content for doc in retrieved_docs])
+    return Tool(
+        name="document_retriever",
+        func=retrieve_context,
+        description="Use this tool to retrieve relevant context from the policy document to answer a user's question."
+    )