now

app.py

@@ -1,139 +1,103 @@
+!pip install -qU langchain-huggingface langchain-community faiss-cpu huggingface-hub==0.27.0
+
 import os
-from typing import List
-from chainlit.types import AskFileResponse
-from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader, PDFLoader
-from aimakerspace.openai_utils.prompts import (
-    UserRolePrompt,
-    SystemRolePrompt,
-    AssistantRolePrompt,
+import getpass
+
+# Load environment variables
+load_dotenv()
+
+YOUR_LLM_ENDPOINT_URL = "https://z1nsc3eoo5nxnoos.us-east-1.aws.endpoints.huggingface.cloud"
+
+from langchain_huggingface import HuggingFaceEndpoint
+
+hf_llm = HuggingFaceEndpoint(
+    endpoint_url=f"{YOUR_LLM_ENDPOINT_URL}",
+    task="text-generation",
+    max_new_tokens=512,
+    top_k=10,
+    top_p=0.95,
+    typical_p=0.95,
+    temperature=0.01,
+    repetition_penalty=1.03,
 )
-from aimakerspace.openai_utils.embedding import EmbeddingModel
-from aimakerspace.vectordatabase import VectorDatabase
-from aimakerspace.openai_utils.chatmodel import ChatOpenAI
-import chainlit as cl
 
-system_template = """\
-Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
-system_role_prompt = SystemRolePrompt(system_template)
+from langchain_core.prompts import PromptTemplate
+
+RAG_PROMPT_TEMPLATE = """\
+<|start_header_id|>system<|end_header_id|>
+You are a helpful assistant. You answer user questions based on provided context. If you can't answer the question with the provided context, say you don't know.<|eot_id|>
+
+<|start_header_id|>user<|end_header_id|>
+User Query:
+{query}
 
-user_prompt_template = """\
 Context:
-{context}
+{context}<|eot_id|>
 
-Question:
-{question}
+<|start_header_id|>assistant<|end_header_id|>
 """
-user_role_prompt = UserRolePrompt(user_prompt_template)
-
-class RetrievalAugmentedQAPipeline:
-    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
-        self.llm = llm
-        self.vector_db_retriever = vector_db_retriever
-
-    async def arun_pipeline(self, user_query: str):
-        context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
-
-        context_prompt = ""
-        for context in context_list:
-            context_prompt += context[0] + "\n"
-
-        formatted_system_prompt = system_role_prompt.create_message()
-
-        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
-
-        async def generate_response():
-            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
-                yield chunk
-
-        return {"response": generate_response(), "context": context_list}
-
-text_splitter = CharacterTextSplitter()
-
-
-def process_file(file: AskFileResponse):
-    import tempfile
-    import shutil
-    
-    print(f"Processing file: {file.name}")
-    
-    # Create a temporary file with the correct extension
-    suffix = f".{file.name.split('.')[-1]}"
-    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
-        # Copy the uploaded file content to the temporary file
-        shutil.copyfile(file.path, temp_file.name)
-        print(f"Created temporary file at: {temp_file.name}")
-        
-        # Create appropriate loader
-        if file.name.lower().endswith('.pdf'):
-            loader = PDFLoader(temp_file.name)
-        else:
-            loader = TextFileLoader(temp_file.name)
-            
-        try:
-            # Load and process the documents
-            documents = loader.load_documents()
-            texts = text_splitter.split_texts(documents)
-            return texts
-        finally:
-            # Clean up the temporary file
-            try:
-                os.unlink(temp_file.name)
-            except Exception as e:
-                print(f"Error cleaning up temporary file: {e}")
 
+rag_prompt = PromptTemplate.from_template(RAG_PROMPT_TEMPLATE)
 
-@cl.on_chat_start
-async def on_chat_start():
-    files = None
-
-    # Wait for the user to upload a file
-    while files == None:
-        files = await cl.AskFileMessage(
-            content="Please upload a Text or PDF file to begin!",
-            accept=["text/plain", "application/pdf"],
-            max_size_mb=2,
-            timeout=180,
-        ).send()
-
-    file = files[0]
-
-    msg = cl.Message(
-        content=f"Processing `{file.name}`..."
-    )
-    await msg.send()
+from langchain_huggingface.embeddings import HuggingFaceEndpointEmbeddings
 
-    # load the file
-    texts = process_file(file)
+YOUR_EMBED_MODEL_URL = "https://jt4esmqgyp7m3fk8.us-east-1.aws.endpoints.huggingface.cloud"
 
-    print(f"Processing {len(texts)} text chunks")
+hf_embeddings = HuggingFaceEndpointEmbeddings(
+    model=YOUR_EMBED_MODEL_URL,
+    task="feature-extraction",
+)
 
-    # Create a dict vector store
-    vector_db = VectorDatabase()
-    vector_db = await vector_db.abuild_from_list(texts)
-    
-    chat_openai = ChatOpenAI()
+!git clone https://github.com/dbredvick/paul-graham-to-kindle.git
 
-    # Create a chain
-    retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
-        vector_db_retriever=vector_db,
-        llm=chat_openai
-    )
-    
-    # Let the user know that the system is ready
-    msg.content = f"Processing `{file.name}` done. You can now ask questions!"
-    await msg.update()
+from langchain_community.document_loaders import TextLoader
 
-    cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
+document_loader = TextLoader("./paul-graham-to-kindle/paul_graham_essays.txt")
+documents = document_loader.load()
 
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 
-@cl.on_message
-async def main(message):
-    chain = cl.user_session.get("chain")
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=30)
+split_documents = text_splitter.split_documents(documents)
+len(split_documents)
 
-    msg = cl.Message(content="")
-    result = await chain.arun_pipeline(message.content)
+from langchain_community.vectorstores import FAISS
 
-    async for stream_resp in result["response"]:
-        await msg.stream_token(stream_resp)
+for i in range(0, len(split_documents), 32):
+  if i == 0:
+    vectorstore = FAISS.from_documents(split_documents[i:i+32], hf_embeddings)
+    continue
+  vectorstore.add_documents(split_documents[i:i+32])
+
+hf_retriever = vectorstore.as_retriever()
+
+from operator import itemgetter
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import RunnablePassthrough
+
+@cl.on_chat_start
+async def start_chat():
+    """
+    This function will be called at the start of every user session. 
+
+    We will build our LCEL RAG chain here, and store it in the user session. 
+
+    The user session is a dictionary that is unique to each user session, and is stored in the memory of the server.
+    """
+    ### BUILD LCEL RAG CHAIN THAT ONLY RETURNS TEXT
+    lcel_rag_chain = {"context": itemgetter("query") | hf_retriever, "query": itemgetter("query")}| rag_prompt | hf_llm
+
+    cl.user_session.set("lcel_rag_chain", lcel_rag_chain)
+
+@cl.on_message
+async def main(message: cl.Message):
+    """
+    This function will be called whenever a user sends a message to the bot.
+    """
+    chainlit_question = message.content
+    response = lcel_rag_chain.invoke({"question": chainlit_question})
+    chainlit_answer = response["response"].content
+
+    msg = cl.Message(content=chainlit_answer)
+    await msg.send()
 
-    await msg.send()

pyproject.toml

@@ -1,14 +1,23 @@
 [project]
-name = "aie5-deploypythonicrag"
+name = "15-open-source-endpoints"
 version = "0.1.0"
-description = "Simple Pythonic RAG App"
+description = "Session 15 - Open Source Endpoints"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.9"
 dependencies = [
-    "chainlit>=2.0.4",
-    "numpy>=2.2.2",
-    "openai>=1.59.9",
-    "pydantic==2.10.1",
-    "pypdf2>=3.0.1",
-    "websockets>=14.2",
+    "asyncio===3.4.3",
+    "chainlit==2.2.1",
+    "huggingface-hub==0.27.0",
+    "langchain-huggingface==0.1.2",
+    "langchain==0.3.19",
+    "langchain-community==0.3.18",
+    "langsmith==0.3.11",
+    "python-dotenv==1.0.1",
+    "tqdm==4.67.1",
+    "langchain-openai==0.3.7",
+    "langchain-text-splitters==0.3.6",
+    "jupyter>=1.1.1",
+    "faiss-cpu>=1.10.0",
+    "websockets>=15.0",
 ]
+