Upload 4 files

main.py

@@ -0,0 +1,178 @@
+import os
+import json
+import tempfile
+import requests
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Union
+from dotenv import load_dotenv
+
+from processing_utility import download_and_parse_document, extract_schema_from_file
+
+# Import functions and constants from the colbert_utils.py file
+# Make sure colbert_utils.py is in the same directory or accessible via PYTHONPATH
+from rag_utils import (
+    process_markdown_with_manual_sections,
+    perform_vector_search,
+    generate_answer_with_groq,
+    CHUNK_SIZE,
+    CHUNK_OVERLAP,
+    TOP_K_CHUNKS,
+    GROQ_MODEL_NAME
+)
+
+load_dotenv()
+
+
+# --- FastAPI App Initialization ---
+app = FastAPI(
+    title="HackRX RAG API",
+    description="API for Retrieval-Augmented Generation from PDF documents.",
+    version="1.0.0",
+)
+
+# --- Groq API Key Setup ---
+# It's highly recommended to set this as an environment variable in production.
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "NOT_FOUND")
+if GROQ_API_KEY == "NOT_FOUND":
+    print("WARNING: GROQ_API_KEY is using a placeholder or hardcoded value. Please set GROQ_API_KEY environment variable for production.")
+
+# --- Pydantic Models for Request and Response ---
+class RunRequest(BaseModel):
+    documents: str  # URL to the PDF document
+    questions: List[str]
+
+class Answer(BaseModel):
+    answer: str
+
+class RunResponse(BaseModel):
+    answers: List[Answer]
+
+# --- Pseudo-functions (Replace with actual implementations if needed) ---
+
+def convert_to_markdown(pdf_url: str) -> str:
+    """
+    PSEUDO-FUNCTION: Downloads the PDF from the URL and returns its local path.
+    In a real scenario, this might involve converting PDF to Markdown,
+    but for process_pdf_with_manual_sections, we just need the local PDF path.
+    """
+    print(f"Downloading PDF from: {pdf_url}")
+    try:
+        response = requests.get(pdf_url, stream=True)
+        response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
+
+        # Create a temporary file to store the PDF
+        temp_pdf_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+        for chunk in response.iter_content(chunk_size=8192):
+            temp_pdf_file.write(chunk)
+        temp_pdf_file.close()
+        print(f"PDF downloaded to temporary path: {temp_pdf_file.name}")
+        return temp_pdf_file.name
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=500, detail=f"Failed to download PDF from URL: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred during PDF download: {e}")
+
+
+def fetch_headings_json(pdf_url: str) -> Dict:
+    """
+    PSEUDO-FUNCTION: Fetches section headings for the PDF.
+    In a real scenario, this would involve a more sophisticated service
+    or logic to extract headings from the PDF.
+    For this example, we return a hardcoded dummy JSON.
+    """
+    print(f"Fetching headings for PDF URL (pseudo-function): {pdf_url}")
+    # This dummy JSON should match the expected schema for process_pdf_with_manual_sections
+    # {"data":{"headings": ["Your Heading"]}}
+    dummy_headings = {
+        "run_id": "dummy-run-id",
+        "extraction_agent_id": "dummy-agent-id",
+        "data": {
+            "headings": [
+                "Policy Wordings",
+                "SECTION A) PREAMBLE",
+                "SECTION B) DEFINITIONS - STANDARD DEFINITIONS",
+                "SECTION B) DEFINITIONS - SPECIFIC DEFINITIONS",
+                "SECTION C) BENEFITS COVERED UNDER THE POLICY",
+                "PART A- COVERAGE- Domestic (Within India Only, for Imperial and Imperial Plus Plans)",
+                "PART B- COVERAGE- International",
+                "SECTION D) EXCLUSIONS- STANDARD EXCLUSIONS APPLICABLE TO PART A- DOMESTIC COVER UNDER SECTION C) BENEFITS COVERED UNDER THE POLICY",
+                "SECTION D) EXCLUSIONS– SPECIFIC EXCLUSIONS APPLICABLE TO PART A- DOMESTIC COVER UNDER SECTION C) BENEFITS COVERED UNDER THE POLICY",
+                "SECTION D) EXCLUSIONS- STANDARD EXCLUSIONS APPLICABLE TO PART B- INTERNATIONAL COVER UNDER SECTION C) BENEFITS COVERED UNDER THE POLICY",
+                "SECTION D) EXCLUSIONS– SPECIFIC EXCLUSIONS APPLICABLE TO INTERNATIONAL COVER UNDER SECTION C) BENEFITS COVERED UNDER THE POLICY",
+                "SECTION E) GENERAL TERMS AND CONDITIONS - STANDARD GENERAL TERMS AND CONDITIONS",
+                "SECTION E) GENERAL TERMS AND CONDITIONS - SPECIFIC TERMS AND CONDITIONS",
+                "SECTION E) GENERAL TERMS AND CLAUSES - STANDARD GENERAL TERMS AND CLAUSES"
+            ]
+        },
+        "extraction_metadata": {
+            "field_metadata": {},
+            "usage": {
+                "num_pages_extracted": 49,
+                "num_document_tokens": 48701,
+                "num_output_tokens": 1229
+            }
+        }
+    }
+    return dummy_headings
+
+# --- API Endpoint ---
+@app.post("/hackrx/run", response_model=RunResponse)
+async def run_rag_pipeline(request: RunRequest):
+    """
+    Runs the RAG pipeline for a given PDF document and a list of questions.
+    """
+    pdf_url = request.documents
+    questions = request.questions
+    
+    local_pdf_path = None
+    try:
+        # Step 1: Download PDF (using pseudo-function)
+        local_markdown_path = await download_and_parse_document(pdf_url) # Renamed from convert_to_markdown to reflect it returns local path
+
+        # Step 2: Fetch headings JSON (using pseudo-function)
+        headings_json = extract_schema_from_file(local_markdown_path)
+        with open("output.json", 'w', encoding='utf-8') as f:
+            json.dump(headings_json, f, indent=4, ensure_ascii=False)
+        if not headings_json or not headings_json.get("headings"):
+            raise HTTPException(status_code=400, detail="Could not retrieve valid headings from the provided PDF URL.")
+
+        # Step 3: Process PDF with manual sections to get chunks with metadata
+        print("Processing PDF into chunks with manual sections...")
+        processed_documents = process_markdown_with_manual_sections(
+            local_markdown_path,
+            headings_json,
+            CHUNK_SIZE,
+            CHUNK_OVERLAP
+        )
+        if not processed_documents:
+            raise HTTPException(status_code=500, detail="Failed to process PDF into document chunks.")
+
+        all_answers = []
+        # Step 4: Iterate through questions, perform search, and generate answers
+        for i, question in enumerate(questions):
+            print(f"Processing question {i+1}/{len(questions)}: '{question}'")
+            # Perform vector search
+            retrieved_results = perform_vector_search(processed_documents, question, TOP_K_CHUNKS)
+
+            if retrieved_results:
+                # Generate answer using Groq
+                answer_text = generate_answer_with_groq(question, retrieved_results, GROQ_API_KEY)
+            else:
+                answer_text = "No relevant information found in the document to answer this question."
+            
+            all_answers.append(Answer(answer=answer_text))
+
+        return RunResponse(answers=all_answers)
+
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        print(f"An unhandled error occurred: {e}")
+        raise HTTPException(status_code=500, detail=f"An internal server error occurred: {e}")
+    finally:
+        # Clean up the temporary PDF file
+        if local_pdf_path and os.path.exists(local_pdf_path):
+            os.unlink(local_pdf_path)
+            print(f"Cleaned up temporary PDF file: {local_pdf_path}")
+

processing_utility.py

@@ -0,0 +1,166 @@
+import httpx      # An asynchronous HTTP client.
+import os         # To handle file paths and create directories.
+import asyncio    # To run synchronous libraries in an async environment.
+from urllib.parse import unquote, urlparse # To get the filename from the URL.
+import uuid       # To generate unique filenames if needed.
+
+from pydantic import HttpUrl
+from langchain_pymupdf4llm import PyMuPDF4LLMLoader
+import json
+import re
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+
+
+import os
+import argparse
+from typing import Optional
+
+# Ensure required libraries are installed.
+# You can install them using:
+# pip install llama_cloud_services pydantic python-dotenv
+
+from llama_cloud_services import LlamaExtract
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+
+class Insurance(BaseModel):
+    """
+    A Pydantic model to define the data schema for extraction.
+    The description helps guide the AI model.
+    """
+    headings: str = Field(description="An array of headings")
+
+
+
+def extract_schema_from_file(file_path: str) -> Optional[Insurance]:
+    """
+    Initializes the LlamaExtract client, creates an agent, and extracts
+    data from the provided file path based on the Resume schema.
+
+    Args:
+        file_path (str): The path to the local markdown file.
+
+    Returns:
+        An instance of the Resume Pydantic model containing the extracted data,
+        or None if the extraction fails or the file doesn't exist.
+    """
+    if not os.path.exists(file_path):
+        print(f"❌ Error: The file '{file_path}' was not found.")
+        return None
+
+    print(f"🚀 Initializing extractor and sending '{file_path}' to LlamaCloud...")
+
+    try:
+        # Initialize the LlamaExtract client.
+        # It will automatically use the LLAMA_CLOUD_API_KEY from the environment.
+        extractor = LlamaExtract()
+
+        # Create an extraction agent with a specific name and data schema.
+        # This configuration is taken directly from your provided code.
+        # Assuming 'extractor' and 'Insurance' are already defined
+        # Define your configuration dictionary
+        agent_config = {
+            "system_prompt": "Identify and extract the primary section/segment headings within this legal or policy document. Focus on headings that establish the overarching theme or context for the entire block of text they introduce. Examples include 'Introduction', 'Definitions', 'Scope', 'Liabilities', or 'Terms and Conditions'. Do not extract subheadings or any headings that merely denote a list item."
+        }
+
+        # Create the agent, passing the config dictionary
+        #agent = extractor.create_agent(name="insurance-parser", data_schema=Insurance)
+        agent = extractor.get_agent(name="insurance-parser")
+
+
+        # Call the agent to extract data from the specified document.
+        print("🤖 Agent created. Starting extraction...")
+        result = agent.extract(file_path)
+
+        if result and result.data:
+            print("✅ Extraction successful!")
+            # The function returns the structured data.
+            return result.data
+        else:
+            print("⚠️ Extraction did not return any data.")
+            return None
+
+    except Exception as e:
+        print(f"\n❌ An error occurred during the API call: {e}")
+        print("Please check your API key, network connection, and file format.")
+        return None
+
+
+
+async def download_and_parse_document(doc_url: HttpUrl) -> str:
+    """
+    Asynchronously downloads a document, saves it to a local directory,
+    and then parses it using LangChain's PyMuPDF4LLMLoader.
+
+    Args:
+        doc_url: The Pydantic-validated URL of the document to process.
+
+    Returns:
+        A single string containing the document's content as structured Markdown.
+    """
+    print(f"Initiating download from: {doc_url}")
+    try:
+        # Create the local storage directory if it doesn't exist.
+        LOCAL_STORAGE_DIR = "data/"
+        os.makedirs(LOCAL_STORAGE_DIR, exist_ok=True)
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(str(doc_url), timeout=30.0, follow_redirects=True)
+            response.raise_for_status()
+        
+        doc_bytes = response.content
+        print("Download successful.")
+
+        # --- Logic to determine the local filename ---
+        # Parse the URL to extract the path.
+        parsed_path = urlparse(str(doc_url)).path
+        # Get the last part of the path and decode URL-encoded characters (like %20 for space).
+        filename = unquote(os.path.basename(parsed_path))
+        
+        # If the filename is empty, create a unique one.
+        if not filename:
+            filename = f"{uuid.uuid4()}.pdf"
+            
+        # Construct the full path where the file will be saved.
+        local_file_path = os.path.join(LOCAL_STORAGE_DIR, filename)
+
+        # Save the downloaded document to the local file.
+        with open(local_file_path, "wb") as f:
+            f.write(doc_bytes)
+        
+        print(f"Document saved locally at: {local_file_path}")
+        print("Parsing document with LangChain's PyMuPDF4LLMLoader...")
+
+        # The loader's 'load' method is synchronous. Run it in a separate thread.
+        def load_document():
+            loader = PyMuPDF4LLMLoader(local_file_path)
+            documents = loader.load()
+            return documents
+
+        documents = await asyncio.to_thread(load_document)
+        
+        if documents:
+            parsed_markdown = "\n\n".join([doc.page_content for doc in documents])
+            print(f"Parsing complete. Extracted {len(parsed_markdown)} characters as Markdown.")
+            # The local file is NOT deleted, as requested.
+            '''with open("sample_schema.json", 'r') as file:
+                # Load the JSON data from the file into a Python variable (dictionary or list)
+                data_variable = json.load(file)'''
+
+            #await process_markdown_with_manual_sections(parsed_markdown, data_variable, chunk_size = 1000, chunk_overlap =200)
+            filename = "hello.md"
+            with open(filename, "w", encoding="utf-8") as f:
+                f.write(parsed_markdown)
+            print(f"Markdown successfully saved to {filename}")
+            #return parsed_markdown
+            return filename
+        else:
+            raise ValueError("PyMuPDF4LLMLoader did not return any content.")
+
+    except httpx.HTTPStatusError as e:
+        print(f"Error downloading document: {e}")
+        raise
+    except Exception as e:
+        print(f"Error during processing: {e}")
+        raise

rag_utils.py

@@ -0,0 +1,273 @@
+import os
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+from ragatouille import RAGPretrainedModel
+from groq import Groq
+import json
+#from PyPDF2 import PdfReader # New import for raw PDF text extraction
+import re
+
+# --- Configuration (can be overridden by the calling app) ---
+CHUNK_SIZE = 1000
+CHUNK_OVERLAP = 200
+TOP_K_CHUNKS = 7
+GROQ_MODEL_NAME = "llama3-8b-8192"
+
+# --- Helper Functions ---
+
+def extract_raw_text_from_pdf(pdf_path: str) -> str:
+    """
+    Extracts raw text from a PDF file using PyPDF2.
+    This is a simpler text extraction compared to LLMSherpa, suitable for manual sectioning.
+    """
+    try:
+        reader = PdfReader(pdf_path)
+        full_text = ""
+        for page in reader.pages:
+            full_text += page.extract_text() + "\n" # Add newline between pages
+        print(f"Extracted raw text from PDF: {len(full_text)} characters.")
+        return full_text
+    except Exception as e:
+        print(f"Error extracting raw text from PDF: {e}")
+        return ""
+
+def process_markdown_with_manual_sections(
+    md_file_path: str,
+    headings_json: dict,
+    chunk_size: int,
+    chunk_overlap: int
+):
+    """
+    Processes a markdown document from a file path by segmenting it based on
+    provided section headings, and then recursively chunking each segment.
+    Each chunk receives the corresponding section heading as metadata.
+
+    Args:
+        md_file_path (str): The path to the input markdown (.md) file.
+        headings_json (dict): A JSON object with schema: {"headings": ["Your Heading 1", "Your Heading 2"]}
+                              This contains the major section headings to split by.
+        chunk_size (int): The maximum size of each text chunk.
+        chunk_overlap (int): The number of characters to overlap between consecutive chunks.
+
+    Returns:
+        tuple[list[Document], list[dict]]: A tuple containing:
+            - list[Document]: A list of LangChain Document objects, each containing
+                              a text chunk and its associated metadata.
+            - list[dict]: A list of dictionaries, each with {"section_heading", "section_text"}
+                          representing the segmented sections for evaluation.
+    """
+    all_chunks_with_metadata = []
+    full_text = ""
+
+    # Check if the file exists and read its content
+    if not os.path.exists(md_file_path):
+        print(f"Error: File not found at '{md_file_path}'")
+        return [], []
+    if not os.path.isfile(md_file_path):
+        print(f"Error: Path '{md_file_path}' is not a file.")
+        return [], []
+    if not md_file_path.lower().endswith(".md"):
+        print(f"Warning: File '{md_file_path}' does not have a .md extension.")
+
+    try:
+        with open(md_file_path, 'r', encoding='utf-8') as f:
+            full_text = f.read()
+    except Exception as e:
+        print(f"Error reading file '{md_file_path}': {e}")
+        return [], []
+
+    if not full_text:
+        print("Input markdown file is empty.")
+        return [], []
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        length_function=len,
+        is_separator_regex=False,
+    )
+
+    # Extract heading texts from the 'headings' key
+    heading_texts = headings_json.get("headings", [])
+    print(f"Identified headings for segmentation: {heading_texts}")
+
+    # Find start indices of all headings in the full text using regex
+    heading_positions = []
+    for heading in heading_texts:
+        # Create a regex pattern to match the heading, ignoring extra whitespace and making it case-insensitive
+        # re.escape() escapes special characters in the heading string
+        # \s* matches zero or more whitespace characters
+        # re.IGNORECASE makes the match case-insensitive
+        pattern = re.compile(r'\s*'.join(re.escape(word) for word in heading.split()))
+        
+        match = pattern.search(full_text)
+        if match:
+            heading_positions.append({"heading_text": heading, "start_index": match.start()})
+        else:
+            print(f"Warning: Heading '{heading}' not found in the markdown text using regex. This section might be missed.")
+
+    # Sort heading positions by their start index
+    heading_positions.sort(key=lambda x: x["start_index"])
+
+    # Segment the text based on heading positions
+    segments_with_headings = []
+    
+    # Handle preface (text before the first heading)
+    if heading_positions and heading_positions[0]["start_index"] > 0:
+        preface_text = full_text[:heading_positions[0]["start_index"]].strip()
+        if preface_text:
+            segments_with_headings.append({
+                "section_heading": "Document Start/Preface",
+                "section_text": preface_text
+            })
+
+    # Iterate through heading positions to define sections
+    for i, current_heading_info in enumerate(heading_positions):
+        start_index = current_heading_info["start_index"]
+        heading_text = current_heading_info["heading_text"]
+        
+        # Determine the end index for the current section
+        end_index = len(full_text)
+        if i + 1 < len(heading_positions):
+            end_index = heading_positions[i+1]["start_index"]
+
+        # Extract section content (from current heading's start to next heading's start)
+        # We include the heading text itself in the section_text
+        section_content = full_text[start_index:end_index].strip()
+        
+        if section_content:
+            segments_with_headings.append({
+                "section_heading": heading_text,
+                "section_text": section_content
+            })
+
+    print(f"Created {len(segments_with_headings)} segments based on provided headings.")
+
+    # Chunk each segment and attach metadata
+    for segment in segments_with_headings:
+        section_heading = segment["section_heading"]
+        section_text = segment["section_text"]
+
+        if section_text:
+            chunks = text_splitter.split_text(section_text)
+            for chunk in chunks:
+                metadata = {
+                    "document_part": "Section", # All these are now considered 'Section'
+                    "section_heading": section_heading,
+                }
+                all_chunks_with_metadata.append(Document(page_content=chunk, metadata=metadata))
+    
+    print(f"Created {len(all_chunks_with_metadata)} chunks with metadata from segmented sections.")
+    
+    with open("output.json", 'w', encoding='utf-8') as f:
+            json.dump(segments_with_headings, f, indent=4, ensure_ascii=False)
+    return all_chunks_with_metadata
+
+def perform_vector_search(documents: list[Document], query: str, top_k: int, rag_model_instance=None) -> list[dict]:
+    """
+    Performs vector search using Ragatouille's ColBERT implementation
+    to retrieve the top k relevant chunks, preserving metadata.
+
+    Args:
+        documents (list[Document]): The list of LangChain Document objects to index and search.
+        query (str): The search query.
+        top_k (int): The number of top relevant chunks to retrieve.
+        rag_model_instance: An optional pre-loaded Ragatouille model instance.
+                            If None, a new one will be loaded.
+
+    Returns:
+        list[dict]: A list of dictionaries, each containing 'content' and 'document_metadata'
+                    from the Ragatouille search results.
+    """
+    if rag_model_instance is None:
+        print("Initializing Ragatouille ColBERT model...")
+        rag = RAGPretrainedModel.from_pretrained("colbert-ir/colbertv2.0")
+    else:
+        rag = rag_model_instance
+
+    # Separate content and metadata for indexing
+    collection_texts = [doc.page_content for doc in documents]
+    collection_metadatas = [doc.metadata for doc in documents]
+
+    index_name = "custom_chunks_index" # Changed index name
+    print("Indexing chunks with Ragatouille (this may take a while for large datasets)...")
+    rag.index(
+        collection=collection_texts,
+        document_metadatas=collection_metadatas,
+        index_name=index_name,
+        overwrite_index=True
+    )
+    print("Indexing complete.")
+
+    print(f"Performing vector search for query: '{query}' (top_k={top_k})...")
+    results = rag.search(query=query, k=top_k)
+
+    print(f"Retrieved {len(results)} top chunks.")
+    return results
+
+def generate_answer_with_groq(query: str, retrieved_results: list[dict], groq_api_key: str) -> str:
+    """
+    Generates an answer using the Groq API based on the query and retrieved chunks' content.
+    Includes metadata in the prompt for better context.
+
+    Args:
+        query (str): The original user query.
+        retrieved_results (list[dict]): A list of dictionaries from Ragatouille search,
+                                        each with 'content' and 'document_metadata'.
+        groq_api_key (str): The Groq API key.
+
+    Returns:
+        str: The generated answer.
+    """
+    if not groq_api_key:
+        return "Error: Groq API key is not set. Cannot generate answer."
+
+    print("Generating answer with Groq API...")
+    client = Groq(api_key=groq_api_key)
+
+    context_parts = []
+    for i, res in enumerate(retrieved_results):
+        content = res.get("content", "")
+        metadata = res.get("document_metadata", {})
+        section_heading = metadata.get("section_heading", "N/A")
+        document_part = metadata.get("document_part", "N/A") # New metadata field
+
+        context_parts.append(
+            f"--- Context Chunk {i+1} ---\n"
+            f"Document Part: {document_part}\n"
+            f"Section Heading: {section_heading}\n"
+            f"Content: {content}\n"
+            f"-------------------------"
+        )
+    context = "\n\n".join(context_parts)
+
+    prompt = (
+        f"You are a specialized document analyzer assistant. Your task is to answer the user's question "
+        f"solely based on the provided context. Pay close attention to the section heading and document part "
+        f"for each context chunk. Ensure your answer incorporates all relevant details, including any legal nuances "
+        f"and conditions found in the context, and is concise, limited to one or two sentences. "
+        f"Do not explicitly mention the retrieved chunks. If the answer cannot be found in the provided context, "
+        f"clearly state that you do not have enough information.\n\n"
+        f"Context:\n{context}\n\n"
+        f"Question: {query}\n\n"
+        f"Answer:"
+    )
+
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model=GROQ_MODEL_NAME,
+            temperature=0.7,
+            max_tokens=500,
+        )
+        answer = chat_completion.choices[0].message.content
+        print("Answer generated successfully.")
+        return answer
+    except Exception as e:
+        print(f"An error occurred during Groq API call: {e}")
+        return "Could not generate an answer due to an API error."

requirements.txt

@@ -0,0 +1,144 @@
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+aiosqlite==0.21.0
+annotated-types==0.7.0
+anyio==4.9.0
+asyncio==3.4.3
+attrs==25.3.0
+banks==2.2.0
+beautifulsoup4==4.13.4
+bitarray==3.6.0
+blinker==1.9.0
+catalogue==2.0.10
+certifi==2025.7.14
+charset-normalizer==3.4.2
+click==8.2.1
+colbert-ai==0.2.21
+colorama==0.4.6
+dataclasses-json==0.6.7
+datasets==4.0.0
+defusedxml==0.7.1
+Deprecated==1.2.18
+dill==0.3.8
+dirtyjson==1.0.8
+distro==1.9.0
+dotenv==0.9.9
+faiss-cpu==1.11.0.post1
+fast_pytorch_kmeans==0.2.2
+fastapi==0.116.1
+filelock==3.18.0
+filetype==1.2.0
+Flask==3.1.1
+frozenlist==1.7.0
+fsspec==2025.3.0
+git-python==1.0.3
+gitdb==4.0.12
+GitPython==3.1.45
+greenlet==3.2.3
+griffe==1.9.0
+groq==0.30.0
+h11==0.16.0
+hf-xet==1.1.5
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.3
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+jiter==0.10.0
+joblib==1.5.1
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.3.27
+langchain-core==0.3.72
+langchain-pymupdf4llm==0.4.1
+langchain-text-splitters==0.3.9
+langsmith==0.4.8
+llama-cloud==0.1.35
+llama-cloud-services==0.6.53
+llama-index==0.12.52
+llama-index-agent-openai==0.4.12
+llama-index-cli==0.4.4
+llama-index-core==0.12.52.post1
+llama-index-embeddings-openai==0.3.1
+llama-index-indices-managed-llama-cloud==0.8.0
+llama-index-instrumentation==0.3.1
+llama-index-llms-openai==0.4.7
+llama-index-multi-modal-llms-openai==0.5.3
+llama-index-program-openai==0.3.2
+llama-index-question-gen-openai==0.3.1
+llama-index-readers-file==0.4.11
+llama-index-readers-llama-parse==0.4.0
+llama-index-workflows==1.2.0
+llama-parse==0.6.53
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+mpmath==1.3.0
+multidict==6.6.3
+multiprocess==0.70.16
+mypy_extensions==1.1.0
+nest-asyncio==1.6.0
+networkx==3.5
+ninja==1.11.1.4
+nltk==3.9.1
+numpy==2.3.2
+onnx==1.18.0
+openai==1.98.0
+orjson==3.11.1
+packaging==25.0
+pandas==2.2.3
+pillow==11.3.0
+platformdirs==4.3.8
+propcache==0.3.2
+protobuf==6.31.1
+psutil==7.0.0
+pyarrow==21.0.0
+pydantic==2.11.7
+pydantic_core==2.33.2
+PyMuPDF==1.26.3
+pymupdf4llm==0.0.27
+pypdf==5.9.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+pytz==2025.2
+PyYAML==6.0.2
+RAGatouille==0.0.9.post2
+regex==2025.7.33
+requests==2.32.4
+requests-toolbelt==1.0.0
+safetensors==0.5.3
+scikit-learn==1.7.1
+scipy==1.16.1
+sentence-transformers==5.0.0
+setuptools==80.9.0
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+soupsieve==2.7
+SQLAlchemy==2.0.42
+srsly==2.5.1
+starlette==0.47.2
+striprtf==0.0.26
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.9.0
+tokenizers==0.21.4
+torch==2.7.1
+tqdm==4.67.1
+transformers==4.49.0
+typing==3.7.4.3
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+tzdata==2025.2
+ujson==5.10.0
+urllib3==2.5.0
+uvicorn==0.35.0
+voyager==2.1.0
+Werkzeug==3.1.3
+wrapt==1.17.2
+xxhash==3.5.0
+yarl==1.20.1
+zstandard==0.23.0