first push

.dockerignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.git
+.dockerignore
+Dockerfile
+*.md

.gitignore

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

Dockerfile

@@ -0,0 +1,13 @@
+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"]

README copy.md

@@ -0,0 +1,10 @@
+---
+title: MY ASSISTANT API
+emoji: 💻
+colorFrom: gray
+colorTo: yellow
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

kg_ia_signature.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55b49436038a45405798f6d05591464b1a35360409d83dbead163921707ac592
+size 7354091

main.py

@@ -0,0 +1,170 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File,Request,Depends,status,BackgroundTasks
+from fastapi.security import OAuth2PasswordBearer
+from pydantic import BaseModel, Json,EmailStr
+from typing import Optional
+from pinecone import Pinecone, ServerlessSpec
+from uuid import uuid4
+import os
+from dotenv import load_dotenv
+from rag import *
+from fastapi.responses import StreamingResponse
+import json
+from prompt import *
+from typing import Literal
+import time
+from fastapi.middleware.cors import CORSMiddleware
+import requests
+
+import smtplib
+from email.mime.text import MIMEText
+
+
+load_dotenv()
+
+## setup pinecone index
+pinecone_api_key = os.environ.get("PINECONE_API_KEY")
+
+pc = Pinecone(api_key=pinecone_api_key)
+
+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=1536,
+        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)
+
+vector_store = PineconeVectorStore(index=index, embedding=embedding)
+
+## setup authorization
+api_keys = [os.environ.get("FASTAPI_API_KEY")]
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")  # use token authentication
+
+
+def api_key_auth(api_key: str = Depends(oauth2_scheme)):
+    if api_key not in api_keys:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Forbidden"
+        )
+
+dev_mode = os.environ.get("DEV")
+
+if dev_mode == "True":
+    app = FastAPI()
+else:
+    app = FastAPI(dependencies=[Depends(api_key_auth)])
+
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+# Pydantic model for the form data
+class ContactForm(BaseModel):
+    name: str
+    email: EmailStr
+    message: str
+
+def send_simple_message(to,subject,text):
+    api_key = os.getenv("MAILGUN_API_KEY")
+
+    return requests.post(
+        "https://api.mailgun.net/v3/sandboxafc6970ffdab40ee9566a4e180b117fd.mailgun.org/messages",
+        auth=("api", api_key),
+        data={"from": "Excited User <mailgun@sandboxafc6970ffdab40ee9566a4e180b117fd.mailgun.org>",
+            "to": [to],
+            "subject": subject,
+            "text": text})
+
+# Function to send email
+def send_email(form_data: ContactForm):
+    # sender_email = os.getenv("SENDER_EMAIL")
+    # sender_password = os.getenv("SENDER_PASSWORD")
+
+    receiver_email = os.getenv("RECEIVER_EMAIL")  # Your email
+
+    # Setup the message content
+    text = f"Name: {form_data.name}\nEmail: {form_data.email}\nMessage: {form_data.message}"
+    title = "New message from your website!"
+
+    # Send the email
+    try:
+        send_simple_message(receiver_email,title,text)
+    except Exception as e:
+        print(e)
+        return {"message": "Failed to send email."}
+
+# Endpoint to handle form submission
+@app.post("/send_email")
+async def send_contact_form(form_data: ContactForm, background_tasks: BackgroundTasks):
+    background_tasks.add_task(send_email, form_data)
+    return {"message": "Email sent successfully!"}
+
+class UserInput(BaseModel):
+    query: str
+    stream: Optional[bool] = False
+    messages: Optional[list[dict]] = []
+
+class ChunkToDB(BaseModel):
+    message: str
+    title: str
+
+
+@app.post("/add_chunk_to_db")
+async def add_chunk_to_db(chunk: ChunkToDB):
+    try:
+        title = chunk.title
+        message = chunk.message
+        return get_vectorstore(text_chunk=message,index=index,title=title)
+    except Exception as e:
+        return {"message": str(e)}
+    
+
+@app.get("/list_vectors")
+async def list_vectors():
+    try:
+        return index.list()
+    except Exception as e:
+        return {"message": str(e)}
+    
+
+@app.post("/generate")
+async def generate(user_input: UserInput):
+    try:
+        print(user_input.stream,user_input.query)
+        if user_input.stream:
+            return StreamingResponse(generate_stream(user_input.query,user_input.messages,index_name=index,stream=True,vector_store=vector_store),media_type="application/json")
+        else:
+            return generate_stream(user_input.query,user_input.messages,index_name=index,stream=False,vector_store=vector_store)
+    except Exception as e:
+        return {"message": str(e)}
+    
+@app.post("/retreive_context")
+async def retreive_context_response(query: str):
+    try:
+        return retreive_context(index=index,query=query)
+    except Exception as e:
+        return {"message": str(e)}
+    
+
+@app.delete("/delete_vector")
+async def delete_vector(filename_id: str):
+    try:
+        return index.delete(ids=[filename_id])
+    except Exception as e:
+        return {"message": str(e)}
+    
+@app.get("/check_server")
+async def check_server():
+    return {"message":"Server is running"}
+
+@app.get("/")
+async def read_root():
+    return {"message":"Welcome to the AI API"}

prompt.py

@@ -0,0 +1,26 @@
+template_sphinx = '''
+Voici un résumé et un bout du récit de {writer}, l'auteur de {book_name}. Vous êtes le Grand Sphinx, maître des énigmes et des questions.
+Vous devez tester si quelqu'un a lu le récit en lui posant une question qui lui ouvrira la porte vers la réalité de ce récit. 
+Votre question doit être en français, et vous devez l'associer aux réponses possibles.
+
+**résumé**:
+{summary}
+
+**Extrait**:
+{excerpt}
+
+**Sortie**:
+La sortie doit être une question en français, qui teste la compréhension du récit. Vous devez fournir les réponses possibles à cette question.
+
+'''
+
+template = '''
+You are an AI assistant for Ilyas Khiat, a future engineer with a major in AI, and software engineering. Your job is to respond to visistors in the most human way . Always provide links if necessary (e.g., LinkedIn: https://www.linkedin.com/in/ilyas-khiat-148a73254/ ) Ensure your tone is pleaseant, and respond precisely to the user's query. if the context is not pertinent or you don't have enough information, **DON'T HALLUCINATE**.
+The context retreived from the user is:
+{context}
+{history}
+The user's query is:
+{query}
+
+Please respond to the user's query in a consis way and well formatted markdown with paragraphs and emojis. If the question is about my values , highlights Ilyas' technical expertise **without exageration**, projects and their **links**, and how he adds value to potential employers, plus soft skills. Add life to your answer and emphasize keywords with bold, MAKE IT **SHORT** in no more than **150 WORDS** or 200 tokens. Ensure your tone is pleasant, engaging, and matches the language of the user's query and your response is not bluffing and exaggerating but honest and convincing.
+'''

rag.py

@@ -0,0 +1,63 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_core.documents import Document
+
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from uuid import uuid4
+from prompt import *
+
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+import os
+
+from langchain_core.tools import tool
+
+import unicodedata
+
+load_dotenv()
+index_name = os.environ.get("INDEX_NAME")
+# Global initialization
+embedding_model = "text-embedding-3-small"
+
+embedding = OpenAIEmbeddings(model=embedding_model)
+# vector_store = PineconeVectorStore(index=index_name, embedding=embedding)
+
+class sphinx_output(BaseModel):
+    question: str = Field(description="The question to ask the user to test if they read the entire book")
+    answers: list[str] = Field(description="The possible answers to the question to test if the user read the entire book")
+
+llm = ChatOpenAI(model="gpt-4o-mini", max_tokens=300, temperature=0.5)
+
+
+def get_random_chunk(chunks: list[str]) -> str:
+    return chunks[tool.random_int(0, len(chunks) - 1)]
+
+def get_vectorstore(chunks: list[str]) -> FAISS:
+    vector_store = FAISS(index=index_name, embedding=embedding)
+    for chunk in chunks:
+        document = Document(text=chunk, id=str(uuid4()))
+        vector_store.index(document)
+    return vector_store
+        
+def generate_stream(query:str,messages = [], model = "gpt-4o-mini", max_tokens = 300, temperature = 0.5,index_name="",stream=True,vector_store=None):
+    try:
+        print("init chat")
+        print("init template")
+        prompt = PromptTemplate.from_template(template)
+        print("retreiving context")
+        context = retreive_context(query=query,index=index_name,vector_store=vector_store)
+        print(f"Context: {context}")
+        llm_chain = prompt | llm | StrOutputParser()
+
+        print("streaming")
+        if stream:
+            return llm_chain.stream({"context":context,"history":messages,"query":query})
+        else:
+            return llm.invoke(query)
+
+    except Exception as e:
+        print(e)
+        return False