api first commit by me :)

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.env

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.12
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,160 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from pydantic import BaseModel, Json
+from uuid import uuid4, UUID
+from typing import Optional
+import pymupdf
+from pinecone import Pinecone, ServerlessSpec
+import os
+from dotenv import load_dotenv
+from rag import *
+from fastapi.responses import StreamingResponse
+
+load_dotenv()
+
+pinecone_api_key = os.environ.get("PINECONE_API_KEY")
+
+pc = Pinecone(api_key=pinecone_api_key)
+
+import time
+
+index_name = os.environ.get("INDEX_NAME") # change if desired
+
+existing_indexes = [index_info["name"] for index_info in pc.list_indexes()]
+
+if index_name not in existing_indexes:
+    pc.create_index(
+        name=index_name,
+        dimension=3072,
+        metric="cosine",
+        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
+    )
+    while not pc.describe_index(index_name).status["ready"]:
+        time.sleep(1)
+
+index = pc.Index(index_name)
+
+app = FastAPI()
+
+
+class UserInput(BaseModel):
+    prompt: str
+    enterprise_id: str
+    stream: Optional[bool] = False
+    messages: Optional[list[dict]] = []
+
+class EnterpriseData(BaseModel):
+    name: str
+    id: Optional[str] = None
+
+tasks = []
+
+@app.get("/")
+def greet_json():
+    return {"Hello": "World!"}
+
+@app.post("/upload")
+async def upload_file(file: UploadFile, enterprise_data: Json[EnterpriseData]):
+    try:
+        # Read the uploaded file
+        contents = await file.read()
+
+        enterprise_name = enterprise_data.name.replace(" ","_").replace("-","_").replace(".","_").replace("/","_").replace("\\","_").strip()
+
+        # Assign a new UUID if id is not provided
+        if enterprise_data.id is None:
+            enterprise_data.id = f"{enterprise_name}_{uuid4()}"
+
+        # Open the file with PyMuPDF
+        pdf_document = pymupdf.open(stream=contents, filetype="pdf")
+
+        # Extract all text from the document
+        text = ""
+        for page in pdf_document:
+            text += page.get_text()
+
+        # Split the text into chunks
+        text_chunks = get_text_chunks(text)
+
+        # Create a vector store
+        vector_store = get_vectorstore(text_chunks, filename=file.filename, file_type="pdf", namespace=enterprise_data.id, index=index)
+
+        if vector_store:
+            return {
+                "file_name":file.filename,
+                "enterprise_id": enterprise_data.id,
+                "number_of_chunks": len(text_chunks),
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Could not create vector store")
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+    finally:
+        await file.close()
+
+@app.get("/documents/{enterprise_id}")
+def get_documents(enterprise_id: str):
+    try:
+        docs_names = []
+        for ids in  index.list(namespace=enterprise_id):
+            for id in ids:
+                name_doc = "_".join(id.split("_")[:-1])
+                if name_doc not in docs_names:
+                    docs_names.append(name_doc)
+        return docs_names
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+    
+@app.delete("/documents/all/{enterprise_id}")
+def delete_all_documents(enterprise_id: str):
+    try:
+        index.delete(namespace=enterprise_id,delete_all=True)
+        return {"message": "All documents deleted"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+    
+import async_timeout
+import asyncio
+
+GENERATION_TIMEOUT_SEC = 60
+
+async def stream_generator(response):
+    async with async_timeout.timeout(GENERATION_TIMEOUT_SEC):
+        try:
+            async for chunk in response:
+                yield {"content":chunk}
+        except asyncio.TimeoutError:
+            raise HTTPException(status_code=504, detail="Stream timed out")
+    
+
+@app.post("/generate-answer/")
+def generate_answer(user_input: UserInput):
+    try:
+        prompt = user_input.prompt
+        enterprise_id = user_input.enterprise_id
+
+        context = get_retreive_answer(enterprise_id, prompt, index)
+        if not context:
+            context = "No context found"
+
+        answer = generate_response_via_langchain(prompt, model="gpt-4o",stream=user_input.stream,context = context , messages=user_input.messages)
+        
+        if user_input.stream:
+            return StreamingResponse(answer, media_type="application/json")
+        
+        return {
+            "prompt": prompt,
+            "answer": answer,
+            "context": context,
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+
+    
+
+
+
+

rag.py

@@ -0,0 +1,108 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_pinecone import PineconeVectorStore
+from langchain_core.documents import Document
+
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+
+
+
+def get_text_from_content_for_doc(content):
+    text = ""
+    for page in content:
+        text += content[page]["texte"]
+    return text
+
+def get_text_from_content_for_audio(content):
+    return content["transcription"]
+
+
+def get_text_chunks(text):
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500, # the character length of the chunck
+        chunk_overlap=100, # the character length of the overlap between chuncks
+        length_function=len # the length function - in this case, character length (aka the python len() fn.)
+    )
+    chunks = text_splitter.split_text(text)
+    return chunks
+
+def get_vectorstore(text_chunks,filename, file_type,namespace,index):
+    try:
+        embedding = OpenAIEmbeddings(model="text-embedding-3-large")
+        vector_store = PineconeVectorStore(index=index, embedding=embedding,namespace=namespace)
+
+        file_name = filename.split(".")[0].replace(" ","_").replace("-","_").replace(".","_").replace("/","_").replace("\\","_").strip()
+
+        documents = []
+        uuids = []
+
+        for i, chunk in enumerate(text_chunks):
+            document = Document(
+            page_content=chunk,
+            metadata={"filename":filename,"file_type":file_type},
+            )
+            uuid = f"{file_name}_{i}"
+            uuids.append(uuid)
+            documents.append(document)
+        
+        vector_store.add_documents(documents=documents, ids=uuids)
+
+        return True
+    
+    except Exception as e:
+        return False
+    
+def get_retreive_answer(enterprise_id,prompt,index):
+    try:
+        
+        embedding = OpenAIEmbeddings(model="text-embedding-3-large")
+        vector_store = PineconeVectorStore(index=index, embedding=embedding,namespace=enterprise_id)
+        
+        retriever = vector_store.as_retriever(
+            search_type="similarity_score_threshold",
+            search_kwargs={"k": 3, "score_threshold": 0.6},
+        )
+        response = retriever.invoke(prompt)
+
+        return response
+    
+    except Exception as e:
+        return False
+    
+def generate_response_via_langchain(query: str, stream: bool = False, model: str = "gpt-4o-mini",context:str="",messages = []) :
+    # Define the prompt template
+    template = "Sachant le context suivant: {context}, et l'historique de la conversation: {messages}, {query}"
+    prompt = PromptTemplate.from_template(template)
+    
+    # Initialize the OpenAI LLM with the specified model
+    llm = ChatOpenAI(model=model)
+    
+    # Create an LLM chain with the prompt and the LLM
+    llm_chain = prompt | llm | StrOutputParser()
+
+    if stream:
+        # Return a generator that yields streamed responses
+        return llm_chain.astream({ "query": query, "context": context, "messages": messages})
+    
+    # Invoke the LLM chain and return the result
+    return llm_chain.invoke({"query": query})
+
+
+
+def setup_rag(file_type,content):
+    if file_type == "pdf":
+        text = get_text_from_content_for_doc(content)
+    elif file_type == "audio":
+        text = get_text_from_content_for_audio(content)
+    
+
+    chunks = get_text_chunks(text)
+
+    vectorstore = get_vectorstore(chunks)
+    
+    return vectorstore
+
+

requirements.txt

@@ -0,0 +1,16 @@
+fastapi
+uvicorn
+python-multipart
+pydantic
+langchain-pinecone 
+pinecone-notebooks
+pinecone-client[grpc]
+async-timeout
+pymupdf
+python-dotenv
+typing-extensions
+langchain
+langchain-openai
+langchain-community
+langchain-pinecone
+