init

.gitignore

@@ -0,0 +1 @@
+.venv

Dockerfile

@@ -0,0 +1,15 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY requirements.txt /app
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

components/Database.py

@@ -0,0 +1,136 @@
+"""
+Contain Wrapper Class for ChormaDB client, that can process and store documents and retrive document chunks.
+"""
+
+from io import BytesIO
+from typing import List
+from typing_extensions import Literal
+import uuid
+import warnings
+import chromadb
+import re
+from .utils import (
+    generate_file_id,
+    chunk_document,
+    generate_embedding,
+    extract_content_from_docx,
+    extract_content_from_pdf,
+)
+
+
+class AdvancedClient:
+
+    def __init__(self, vector_database_path: str = "vectorDB") -> None:
+        self.client = chromadb.PersistentClient(path=vector_database_path)
+        self.exsisting_collections = [
+            collection.name for collection in self.client.list_collections()
+        ]
+        self.selected_collections = []
+
+    def create_or_get_collection(
+        self,
+        file_names: List[str],
+        file_types: List[Literal["pdf", "docx"]],
+        file_datas,
+    ):
+        collections = []
+        for data in zip(file_names, file_types, file_datas):
+
+            file_name, file_type, file_data = data
+            file_id = generate_file_id(file_bytes=file_data)
+            file_exisis = file_id in self.exsisting_collections
+
+            if file_exisis:
+                collection = file_id
+
+            else:
+                collection = self.client.create_collection(name=file_id)
+                file_buffer = BytesIO(file_data)
+
+                if file_type == "pdf":
+                    document, pil_images = extract_content_from_pdf(file_buffer)
+                    chunks = chunk_document(document)
+                    ids = [f"{uuid.uuid4()}_id_{x}" for x in range(1, len(chunks) + 1)]
+                    embeddings = generate_embedding(
+                        chunks, embedding_model="znbang/bge:small-en-v1.5-q8_0"
+                    )
+                    metadatas = []
+
+                    for chunk in chunks:
+                        imgs_found = re.findall(
+                            pattern=r"<img\s+src='([^']*)'>", string=chunk
+                        )
+                        chunk_imgs = []
+                        if len(imgs_found) > 0:
+                            for img in imgs_found:
+                                chunk_imgs.append(pil_images[int(img)])
+                        metadatas.append(
+                            {"images": str(chunk_imgs), "file_name": file_name}
+                        )
+
+                elif file_type == "docx":
+                    document = extract_content_from_docx(file_buffer)
+                    chunks = chunk_document(document)
+                    ids = [f"{uuid.uuid4()}_id_{x}" for x in range(1, len(chunks) + 1)]
+
+                    embeddings = generate_embedding(
+                        chunks, embedding_model="znbang/bge:small-en-v1.5-q8_0"
+                    )
+                    metadatas = [{"file_name": file_name} for _ in chunks]
+
+                else:
+                    raise Exception(
+                        f"Given format '.{file_type}' is currently not supported."
+                    )
+
+                collection.add(
+                    ids=ids,
+                    embeddings=embeddings,  # type: ignore
+                    documents=chunks,
+                    metadatas=metadatas,  # type: ignore
+                )
+                collection = file_id
+            collections.append(collection)
+
+        self.selected_collections = collections
+
+    def retrieve_chunks(self, query: str, number_of_chunks: int = 3):
+        if len(self.selected_collections) == 0:
+
+            warnings.warn(
+                message=f"No collection is selected using all the exsisting collections, total collections : {len(self.exsisting_collections)}"
+            )
+            collections = [self.client.get_collection("UNION")]
+            self.selected_collections = collections
+        else:
+            collections = [
+                self.client.get_collection(collection_name)
+                for collection_name in self.selected_collections
+            ]
+
+        query_emb = generate_embedding(
+            [query], embedding_model="znbang/bge:small-en-v1.5-q8_0"
+        )
+
+        retrieved_docs = []
+
+        for collection in collections:
+            results = collection.query(
+                query_embeddings=query_emb,
+                n_results=5,
+                include=["documents", "metadatas", "distances"],
+            )
+
+            for i in range(len(results["ids"][0])):
+                retrieved_docs.append(
+                    {
+                        "document": results["documents"][0][i],
+                        "metadata": results["metadatas"][0][i],
+                        "distance": results["distances"][0][i],
+                        "collection": collection.name,
+                    }
+                )
+
+        retrieved_docs = sorted(retrieved_docs, key=lambda x: x["distance"])
+
+        return retrieved_docs[:number_of_chunks]

components/LLM.py

@@ -0,0 +1,181 @@
+"""
+Contain Classes for LLM inference for RAG pipeline.
+"""
+
+### ** Make input output tokens as class properties **
+
+from openai import OpenAI
+from .utils import count_tokens
+import json
+
+
+class rLLM:
+    def __init__(self, llm_name: str, api_key: str) -> None:
+        self.llm_name = llm_name
+        self.llm_client = OpenAI(
+            api_key=api_key, base_url="https://api.together.xyz/v1"
+        )
+        with open("components/prompts.json", "r") as file:
+            SysPrompt = json.load(file)["SysPrompt"]
+        self.sys_prompt = SysPrompt
+
+    def generate_rag_response(self, context: str, prompt: str, message_history):
+        """
+        Generates a natural language response for user query(prompt) based on provided
+        context and message history, in Q&A style.
+        """
+
+        system_prompt = self.sys_prompt
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ]
+
+        for message in message_history[-6:-1]:
+            if message["role"] == "assistant":
+                messages.append({"role": "assistant", "content": message["content"]})
+            else:
+                messages.append(message)
+
+        messages.append(
+            {"role": "user", "content": f"CONTEXT:\n{context}QUERY:\n{prompt}"},
+        )
+
+        stream = self.llm_client.chat.completions.create(
+            model=self.llm_name,
+            messages=messages,
+            stream=True,
+        )
+
+        output = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                content = chunk.choices[0].delta.content
+                output += content
+                yield 0, content
+
+        input_token_count = count_tokens(
+            string="\n".join([i["content"] for i in messages])
+        )
+
+        output_token_count = count_tokens(string=output)
+
+        yield 1, (output, input_token_count, output_token_count)
+
+    def HyDE(self, query: str, message_history):
+        """
+        Rephare/rewrite the user query to include more semantics, hence improving the
+        semantic search based retreival.
+        """
+
+        system_prompt = """You are an AI assistant specifically designed to generate hypothetical answers for semantic search. Your primary function is to create concise Maximum 100-150 words, informative, and relevant responses to user queries. Make sure to capture the original intent of the user query (by including keywords present in user query) as these responses will be used to generate embeddings for improved semantic search results.
+"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ]
+
+        for message in message_history[-6:-1]:
+            if message["role"] == "assistant":
+                messages.append({"role": "assistant", "content": message["content"]})
+            else:
+                messages.append(message)
+
+        messages.append(
+            {"role": "user", "content": f"\n\nQUERY:\n{query}"},
+        )
+
+        response = self.llm_client.chat.completions.create(
+            model="meta-llama/Llama-3-8b-chat-hf",
+            messages=messages,
+            max_tokens=500,
+        )
+        response = response.choices[0].message.content
+        return response
+
+    ### NOT IN USE
+
+    def generate_rag_chat_response(self, context: str, prompt: str, message_history):
+        """
+        NOT IN USE CURRENTLY
+        Generates a natural language response for user query(prompt) based on provided
+        context and message history, in Q&A style.
+        """
+
+        system_prompt = """You are a helpful legal compliance CHAT assistant designed to answer and resolve user query in chat format hence quick and *small* responses.
+
+Instructions:
+1. Use the provided CONTEXT to inform your responses, citing specific parts when relevant.
+2. If unable to answer the QUERY, politely inform the user and suggest what additional information might help.
+3. Give a small/chatty format response.
+4. Try to give decisive responses that can help user to make informed decision. 
+5. Format responses for readability, include bold words to give weightage.
+
+Don't add phrases like "According to provided context.." etcectra. """
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ]
+
+        for message in message_history[-6:-1]:
+            if message["role"] == "assistant":
+                messages.append({"role": "assistant", "content": message["content"]})
+            else:
+                messages.append(message)
+
+        messages.append(
+            {"role": "user", "content": f"CONTEXT:\n{context}\n\nQUERY:\n{prompt}"},
+        )
+
+        stream = self.llm_client.chat.completions.create(
+            model=self.llm_name,
+            messages=messages,
+            stream=True,
+        )
+
+        output = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                content = chunk.choices[0].delta.content
+                output += content
+                yield 0, content
+
+        input_token_count = count_tokens(
+            string="\n".join([i["content"] for i in messages])
+        )
+
+        output_token_count = count_tokens(string=output)
+
+        yield 1, (output, input_token_count, output_token_count)
+
+    def rephrase_query(self, query: str, message_history):
+        """
+        NOT IN USE CURRENTLY
+        Rephare/rewrite the user query to include more semantics, hence improving the
+        semantic search based retreival.
+        """
+
+        system_prompt = """You are an AI assistant specifically designed to rewrite the user QUERY for semantic search. Your primary function is to create more comprehensive, semantically rich query *while maintaining the original intent of the user*. These responses will be used to generate embeddings for improved semantic search results.
+Do not include any other comments or text, other than the repharased/rewritten query.
+"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+        ]
+
+        for message in message_history[-6:-1]:
+            if message["role"] == "assistant":
+                messages.append({"role": "assistant", "content": message["content"]})
+            else:
+                messages.append(message)
+
+        messages.append(
+            {"role": "user", "content": f"\n\nQUERY:\n{query}"},
+        )
+
+        response = self.llm_client.chat.completions.create(
+            model="meta-llama/Llama-3-8b-chat-hf",
+            messages=messages,
+        )
+        response = response.choices[0].message.content
+        return response

components/prompts.json

@@ -0,0 +1,3 @@
+{
+  "SysPrompt": "You are an advanced AI assistant specializing in Retrieval-Augmented Generation (RAG) for question answering. Your primary function is to provide accurate, relevant, and contextually appropriate answers to user queries by leveraging both your general knowledge and the CONTEXT retrieved from a given knowledge base.\n  \n## Your Responsibilities:\n1. Carefully analyze user query to understand the intent and context.\n2. Synthesize provided CONTEXT with your general knowledge to formulate comprehensive answers.\n4. Clearly distinguish between information from the knowledge base and your general knowledge or inferences.\n5. When uncertain, acknowledge the limitations of your knowledge or the available information.\n6. Maintain a professional, helpful, and courteous demeanor in all interactions.\n\n## Guidelines for Responses:\n1. Provide concise answers for straightforward questions, and more detailed explanations for complex topics.\n2. Use bullet points or numbered lists for clarity when presenting multiple pieces of information.\n3. Include relevant examples or analogies to aid understanding when appropriate.\n4. If the query cannot be fully answered with the available information, explain what is known and what remains uncertain.\n\nRemember, your goal is to assist users by providing accurate, helpful, and contextually relevant information. Always strive to enhance the user's understanding of the topic at hand."
+}

components/utils.py

@@ -0,0 +1,173 @@
+"""
+Contains Utility functions for LLM and Database module. Along with some other misllaneous functions.
+"""
+
+from pymupdf import pymupdf
+from docx import Document
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+import tiktoken
+import base64
+import hashlib
+import ollama
+from typing import List
+from openai import OpenAI
+import os
+
+TOGETHER_API = str(os.getenv("TOGETHER_API_KEY"))
+
+
+def get_preview_pdf(file_bytes: bytes):
+    """Returns first 3 pages of a PDF file."""
+
+    doc = pymupdf.open(stream=file_bytes, filetype="pdf")
+    sliced_doc = pymupdf.open()
+    sliced_doc.insert_pdf(doc, from_page=0, to_page=2)
+
+    return sliced_doc.tobytes()
+
+
+def count_tokens(string: str) -> int:
+    """Returns number of tokens in inputted string."""
+
+    tokenizer = tiktoken.get_encoding("cl100k_base")
+    return len(tokenizer.encode(text=string))
+
+
+def create_refrences(retrieved_docs):
+    """Create a refrences of chunks/pecies used in generating reponse, in markdown format"""
+
+    refrences = ""
+    for doc in retrieved_docs:
+        try:
+            chunk_imgs = eval(doc["metadata"]["images"])
+        except:
+            chunk_imgs = None
+        chunk = doc["document"]
+
+        if chunk_imgs:
+            chunk_split = chunk.split("<img src='")
+            chunk_with_img = ""
+
+            if len(chunk_split) > 1:
+                for i in range(0, len(chunk_split) - 1):
+                    img_bytes = chunk_imgs[i]
+                    base64_str = base64.b64encode(img_bytes).decode("utf-8")
+                    chunk_with_img += (
+                        chunk_split[i].strip()
+                        + f"\n<img src='data:image/png;base64,{base64_str}'>\n"
+                        + chunk_split[i + 1][3:]
+                    )
+            else:
+                chunk_with_img = chunk
+
+            refrences += (
+                f"###### {doc['metadata']['file_name']}\n\n{chunk_with_img}\n\n"
+            )
+        else:
+            chunk = doc["document"]
+            refrences += f"###### {doc['metadata']['file_name']}\n\n{chunk}\n\n**Distance : {doc['distance']}**\n\n"
+
+    return refrences
+
+
+def generate_file_id(file_bytes):
+    """Generate a Unique file ID for given file."""
+
+    hash_obj = hashlib.sha256()
+    hash_obj.update(file_bytes[:4096])
+    file_id = hash_obj.hexdigest()[:63]
+    return str(file_id)
+
+
+def extract_content_from_docx(docx_content):
+    """Extract content (text) from DOCX file"""
+    doc = Document(docx_content)
+    full_text = []
+    for para in doc.paragraphs:
+        full_text.append(para.text)
+    content = "\n".join(full_text)
+    return content
+
+
+def extract_content_from_pdf(pdf_content):
+    """Extereact content (Image + text) from PDF files."""
+
+    doc = pymupdf.open(stream=pdf_content, filetype="pdf")
+    DOCUMENT = ""
+    pil_images = []
+
+    for page in doc:
+
+        blocks = page.get_text_blocks()  # type: ignore
+        images = page.get_images()  # type: ignore
+
+        # Create a list of all elements (text blocks and images) with their positions
+        elements = [(block[:4], block[4], "text") for block in blocks]
+
+        img_list = []
+        for img in images:
+            try:
+                img_bbox = page.get_image_rects(img[0])[0]  # type: ignore
+                if len(img_bbox) > 0:
+                    img_data = (img_bbox, img[0], "image")
+                    img_list.append(img_data)
+                else:
+                    continue
+            except Exception as e:
+                print("Exception :", e)
+                pass
+
+        elements.extend(img_list)
+
+        # Sort elements by their vertical position (top coordinate)
+        elements.sort(key=lambda x: x[0][1])
+
+        for element in elements:
+            if element[2] == "text":
+                DOCUMENT += element[1]
+            else:
+                xref = element[1]
+                base_image = doc.extract_image(xref)
+                image_bytes = base_image["image"]
+
+                # Save the image
+                image = image_bytes
+                pil_images.append(image)
+                DOCUMENT += f"\n<img src='{len(pil_images)-1}'>\n\n"
+    return DOCUMENT, pil_images
+
+
+def chunk_document(document, chunk_size=200, overlap=10, encoding_name="cl100k_base"):
+    """Split/Chunk Document with Recursive splitting strategy"""
+
+    splitter = RecursiveCharacterTextSplitter(
+        separators=["\n\n", "\n", " ", ""], keep_separator=True
+    ).from_tiktoken_encoder(
+        encoding_name=encoding_name, chunk_size=chunk_size, chunk_overlap=overlap
+    )
+    chunks = splitter.split_text(document)
+    return chunks
+
+
+def generate_embedding_ollama(
+    texts: List[str], embedding_model: str
+) -> List[List[float]]:
+    """Generate Embeddings for the givien pieces of texts."""
+
+    embeddings = []
+    for text in texts:
+        embedding = ollama.embeddings(model=embedding_model, prompt=text)["embedding"]
+        embeddings.append(list(embedding))
+
+    return embeddings
+
+
+def generate_embedding(texts: List[str], embedding_model: str) -> List[List[float]]:
+    """Generate Embeddings for the givien pieces of texts."""
+
+    client = OpenAI(api_key=TOGETHER_API, base_url="https://api.together.xyz/v1")
+    embeddings_response = client.embeddings.create(
+        input=texts, model="BAAI/bge-large-en-v1.5"
+    ).data
+    embeddings = [i.embedding for i in embeddings_response]
+    return embeddings

main.py

@@ -0,0 +1,235 @@
+from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, HTTPException
+import os
+import base64
+
+from pydantic import BaseModel, Field
+from typing import List, Dict
+from typing_extensions import Literal
+
+import logging
+import sqlite3
+import time
+import asyncio
+
+from components.LLM import rLLM
+from components.Database import AdvancedClient
+from components.utils import create_refrences
+
+# LLM API key
+TOGETHER_API = str(os.getenv("TOGETHER_API_KEY"))
+
+# Configure logging
+logging.basicConfig(
+    level=logging.WARNING,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.FileHandler("app.log"), logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# SQLite setup
+DB_PATH = "data/conversations.db"
+
+# In-memory storage for conversations
+conversations: Dict[str, List[Dict[str, str]]] = {}
+COLLECTIONS: Dict[str, List[str]] = {}
+last_activity: Dict[str, float] = {}
+
+
+# initialize SQLite database
+def init_db():
+    logger.info("Initializing database")
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute(
+        """CREATE TABLE IF NOT EXISTS conversations
+                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                  conversation_id TEXT,
+                  collections TEXT,
+                  lastmessage TEXT
+                  timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)"""
+    )
+    conn.commit()
+    conn.close()
+    logger.info("Database initialized successfully")
+
+
+init_db()
+
+
+def update_db(conversation_id, collections, message):
+    logger.info(f"Updating database for conversation: {conversation_id}")
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    c.execute(
+        """INSERT INTO conversations (conversation_id, collections, lastmessage)
+                 VALUES (?, ?, ?)""",
+        (conversation_id, collections, message),
+    )
+    conn.commit()
+    conn.close()
+    logger.info("Database updated successfully")
+
+
+def get_collection_from_db(conversation_id):
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        c = conn.cursor()
+        c.execute(
+            """SELECT collections FROM conversations WHERE conversation_id = ?""",
+            (conversation_id,),
+        )
+        collection = c.fetchone()
+        if collection:
+            return collection[0]
+        else:
+            return None
+    finally:
+        conn.close()
+
+
+async def clear_inactive_conversations():
+    while True:
+        logger.info("Clearing inactive conversations")
+        current_time = time.time()
+        inactive_convos = [
+            conv_id
+            for conv_id, last_time in last_activity.items()
+            if current_time - last_time > 1800
+        ]  # 30 minutes
+        for conv_id in inactive_convos:
+            if conv_id in conversations:
+                del conversations[conv_id]
+            if conv_id in last_activity:
+                del last_activity[conv_id]
+            if conv_id in collections:
+                del collections[conv_id]
+        logger.info(f"Cleared {len(inactive_convos)} inactive conversations")
+        await asyncio.sleep(60)  # Check every minute
+
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Starting up the application")
+    asyncio.create_task(clear_inactive_conversations())
+
+
+class UploadedFiles(BaseModel):
+    ConversationID: str = Field(examples=["123e4567-e89b-12d3-a456-426614174000"])
+    FileNames: List[str] = Field(examples=[["file_1.pdf", "file_2.docx"]])
+    FileTypes: List[Literal["pdf", "docx"]] = Field(examples=[["pdf", "docx"]])
+    FileData: List[str]
+
+
+class UserInput(BaseModel):
+    ConversationID: str = Field(examples=["123e4567-e89b-12d3-a456-426614174000"])
+    Query: str = Field(examples=["What is IT ACT 2000?"])
+
+
+class ChunkResponse(BaseModel):
+    chunk: str = Field(examples=["This is", "streaming"])
+
+
+class CompletedResponse(BaseModel):
+    FullResponse: str = Field(examples=["This is a complete response"])
+    InputToken: int = Field(examples=[1024, 2048])
+    OutputToken: int = Field(examples=[4096, 7000])
+
+
+@app.post("/initiate_conversation")
+async def get_conversation_id(files: UploadedFiles):
+    # Decoding bytes data
+    data = [base64.b64decode(b) for b in files.FileData]
+    vector_db = AdvancedClient()
+    vector_db.create_or_get_collection(
+        file_names=files.FileNames,
+        file_types=files.FileTypes,
+        file_datas=data,
+    )
+
+    file_ids = vector_db.selected_collections
+
+    # update in-memory data
+    COLLECTIONS[files.ConversationID] = file_ids
+    conversations[files.ConversationID] = []
+    last_activity[files.ConversationID] = time.time()
+
+    # update SQL data
+    update_db(
+        conversation_id=files.ConversationID,
+        collections="|".join(file_ids),
+        message="NONE",
+    )
+    return True
+
+
+@app.post("/get_response")
+async def get_response_streaming(user_query: UserInput):
+
+    llm = rLLM(llm_name="meta-llama/Llama-3-8b-chat-hf", api_key=TOGETHER_API)
+
+    conv_id = user_query.ConversationID
+    try:
+        print(COLLECTIONS)
+        if conv_id in COLLECTIONS:
+            collection_to_use = COLLECTIONS[conv_id]
+            last_activity[conv_id] = time.time()
+        else:
+            collections = get_collection_from_db(conv_id)
+            if collections:
+                collection_to_use = collections.split("|")
+
+    except:
+        return HTTPException(
+            status_code=404,
+            detail="Conversation ID does not exist, please register one with /initiate_conversation endpoint.",
+        )
+
+    vector_db = AdvancedClient()
+    # update database to user conversation's documents
+    vector_db.selected_collections = collection_to_use
+
+    try:
+        conversation_history = conversations[conv_id]
+    except:
+        conversations[conv_id] = []
+        conversation_history = []
+    rephrased_query = llm.HyDE(
+        query=user_query.Query, message_history=conversation_history
+    )
+
+    retrieved_docs = vector_db.retrieve_chunks(query=rephrased_query)
+
+    conversations[conv_id].append({"role": "user", "content": user_query.Query})
+
+    context = ""
+    for i, doc in enumerate(retrieved_docs, start=1):
+        context += f"Refrence {i}\n\n" + doc["document"] + "\n\n"
+
+    def streaming():
+        for data in llm.generate_rag_response(
+            context=context,
+            prompt=user_query.Query,
+            message_history=conversation_history,
+        ):
+            completed, chunk = data
+            if completed:
+                full_response, input_token, output_token = chunk
+
+                conversations[conv_id].append(
+                    {"role": "assistant", "content": full_response}
+                )
+
+                logger.info(msg=f"Input:{input_token} \nOuptut:{output_token}")
+                yield "\n\n<REFRENCES>\n" + create_refrences(
+                    retrieved_docs
+                ) + "\n</REFRENCES>"
+
+            else:
+                chunk = chunk
+                yield chunk
+
+    return StreamingResponse(streaming(), media_type="text/event-stream")

requirements.txt

@@ -0,0 +1,108 @@
+annotated-types==0.7.0
+anyio==4.4.0
+asgiref==3.8.1
+backoff==2.2.1
+bcrypt==4.2.0
+build==1.2.1
+cachetools==5.4.0
+certifi==2024.7.4
+charset-normalizer==3.3.2
+chroma-hnswlib==0.7.6
+chromadb==0.5.5
+click==8.1.7
+coloredlogs==15.0.1
+Deprecated==1.2.14
+distro==1.9.0
+dnspython==2.6.1
+email_validator==2.2.0
+exceptiongroup==1.2.2
+fastapi==0.112.0
+fastapi-cli==0.0.5
+filelock==3.15.4
+flatbuffers==24.3.25
+fsspec==2024.6.1
+google-auth==2.32.0
+googleapis-common-protos==1.63.2
+grpcio==1.65.4
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+huggingface-hub==0.24.5
+humanfriendly==10.0
+idna==3.7
+importlib_metadata==8.0.0
+importlib_resources==6.4.0
+Jinja2==3.1.4
+jsonpatch==1.33
+jsonpointer==3.0.0
+kubernetes==30.1.0
+langchain-core==0.2.28
+langchain-text-splitters==0.2.2
+langsmith==0.1.96
+lxml==5.2.2
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+mmh3==4.1.0
+monotonic==1.6
+mpmath==1.3.0
+numpy==1.26.4
+oauthlib==3.2.2
+ollama==0.3.1
+onnxruntime==1.18.1
+openai==1.38.0
+opentelemetry-api==1.26.0
+opentelemetry-exporter-otlp-proto-common==1.26.0
+opentelemetry-exporter-otlp-proto-grpc==1.26.0
+opentelemetry-instrumentation==0.47b0
+opentelemetry-instrumentation-asgi==0.47b0
+opentelemetry-instrumentation-fastapi==0.47b0
+opentelemetry-proto==1.26.0
+opentelemetry-sdk==1.26.0
+opentelemetry-semantic-conventions==0.47b0
+opentelemetry-util-http==0.47b0
+orjson==3.10.6
+overrides==7.7.0
+packaging==24.1
+posthog==3.5.0
+protobuf==4.25.4
+pyasn1==0.6.0
+pyasn1_modules==0.4.0
+pydantic==2.8.2
+pydantic_core==2.20.1
+Pygments==2.18.0
+PyMuPDF==1.24.9
+PyMuPDFb==1.24.9
+PyPika==0.48.9
+pyproject_hooks==1.1.0
+python-dateutil==2.9.0.post0
+python-docx==1.1.2
+python-dotenv==1.0.1
+python-multipart==0.0.9
+PyYAML==6.0.1
+regex==2024.7.24
+requests==2.32.3
+requests-oauthlib==2.0.0
+rich==13.7.1
+rsa==4.9
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+starlette==0.37.2
+sympy==1.13.1
+tenacity==8.5.0
+tiktoken==0.7.0
+tokenizers==0.19.1
+tomli==2.0.1
+tqdm==4.66.5
+typer==0.12.3
+typing_extensions==4.12.2
+urllib3==2.2.2
+uvicorn==0.30.5
+uvloop==0.19.0
+watchfiles==0.22.0
+websocket-client==1.8.0
+websockets==12.0
+wrapt==1.16.0
+zipp==3.19.2