Basic set-up.

.gitignore

@@ -9,6 +9,12 @@ wheels/
 # Virtual environments
 .venv
 
+# secrets
+*.env
+
 # application files
 .gradio
-*.log
+*.log
+
+# sanboxes
+*.ipynb

README.md

@@ -50,5 +50,9 @@ Alternatively, with a different dependency manager such as `venv` install direct
 
 
 
+## To-Do
+ - create bsaic set-up with Qdrant in memory, ingestion pipeline
+ - create basic set-up where retrieval is not yet having an llm call
+ - connect to frontend with "invoke" and deletion of memory
 
 

app.py

@@ -1,13 +1,42 @@
 from typing import Any
 
 import gradio as gr
+from langchain_openai import OpenAIEmbeddings
+from langchain_qdrant import QdrantVectorStore
 import structlog
 
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams, SparseVectorParams
+
 import logging_config as _
+from conversation.main import graph
+from ingestion.main import ingest_document
+
+from config import app_settings
 
 # Create a logger instance
 logger = structlog.get_logger(__name__)
 
+embeddings = OpenAIEmbeddings(
+    model=app_settings.embedding_model,
+    api_key=app_settings.llm_api_key
+)
+
+client = QdrantClient(app_settings.vector_db_url)
+if not client.collection_exists(app_settings.vector_db_collection_name):
+    client.create_collection(
+        collection_name=app_settings.vector_db_collection_name,
+        vectors_config=VectorParams(size=app_settings.embedding_size, distance=Distance.COSINE),
+        sparse_vectors_config={'langchain-sparse': SparseVectorParams(index=None, modifier=None)}
+    )
+vector_store = QdrantVectorStore(
+    client=client,
+    collection_name=app_settings.vector_db_collection_name,
+    embedding=embeddings,
+)
+
+
+
 with open("static/style.css", "r") as f:
     css = f.read()
     logger.info("Successfully loaded styles.")
@@ -18,23 +47,29 @@ def bot(message, history) -> list[Any]:
     
     With multi-modal inputs text and each file is treated as separate message.
     """
+   
     logger.info("This is the history", history=history)
     
     # enable message edit
     if isinstance(message, str):
         message = {"text": message}
+        
+    # process files
+    for file in message.get("files"):
+        logger.info("Received file", file=file)
+        ingest_document(file, vector_store)
     
     # create text response
-    response = []
-    response.append("You wrote: '" + message.get("text") + "' and uploaded:")
+    # TODO: see how state can be set in chat interface
+    config = {"configurable": {"thread_id": "abc123"}}
+    response = graph.invoke(
+        {"messages": [{"role": "user", "content": message.get("text")}]},
+        config=config,
+        )
     
-    # display files (exemplary)
-    if message.get("files"):
-        for file in message.get("files"):
-            response.append(gr.File(value=file))
+    logger.info("Generated a response", response=response)
 
-    logger.info(response=response)
-    return response
+    return [response["messages"][-1].content]
 
 
 demo = gr.ChatInterface(

config.py

@@ -31,6 +31,7 @@ class AppSettings(Settings):
     llm_model: str
     embedding_url: str
     embedding_model: str
+    embedding_size: int
     vector_db_url: str
     vector_db_collection_name: str
 
@@ -42,4 +43,6 @@ class AppSettings(Settings):
         env_file=".env",
         env_file_encoding="utf-8",
         extra="ignore",
-    )
+    )
+
+app_settings = AppSettings()

conversation/generate.py

@@ -0,0 +1,86 @@
+import structlog
+from langchain.chat_models import init_chat_model
+from langchain_core.messages import SystemMessage, AIMessage, HumanMessage
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import (
+    ChatPromptTemplate,
+    MessagesPlaceholder,
+)
+from langchain_core.runnables import RunnableParallel
+from langgraph.graph import MessagesState
+from pydantic import BaseModel
+
+from config import app_settings
+
+logger = structlog.get_logger(__name__)
+
+llm = init_chat_model(
+    app_settings.llm_model,
+    model_provider="openai",
+    api_key=app_settings.llm_api_key
+)
+
+
+# RAG answer synthesis prompt
+system_template = """
+Answer the user's questions based on the below context. 
+If the context doesn't contain any relevant information to the question, don't make something up and just say "I don't know":
+
+<context>
+{context}
+</context>
+"""
+
+ANSWER_PROMPT = ChatPromptTemplate.from_messages(
+    [
+        ("system", system_template),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("user", "{question}"),
+    ]
+)
+
+
+# User input
+class ChatHistory(BaseModel):
+    chat_history: list[AIMessage | HumanMessage]
+    question: str
+
+
+_inputs = RunnableParallel(
+    {
+        "question": lambda x: x["question"],
+        # "chat_history": lambda x: _format_chat_history(x["chat_history"]),
+        "chat_history": lambda x: x["chat_history"],
+        "context": lambda x: x["context"]
+    }
+).with_types(input_type=ChatHistory)
+
+chain = _inputs | ANSWER_PROMPT | llm | StrOutputParser()
+
+
+def generate(state: MessagesState):
+    """Generate answer."""
+    # Get generated ToolMessages
+    recent_tool_messages = []
+    for message in reversed(state["messages"]):
+        if message.type == "tool":
+            recent_tool_messages.append(message)
+        else:
+            break
+    tool_messages = recent_tool_messages[::-1]
+    # Format into prompt
+    docs_content = "\n\n".join(doc.content for doc in tool_messages)
+    logger.info("Tool messages", context=docs_content)
+    
+    conversation_messages = [
+        message
+        for message in state["messages"]
+        if message.type in ("human", "system")
+        or (message.type == "ai" and not message.tool_calls)
+    ]
+    response = chain.invoke({
+        "question": conversation_messages[-1].content,
+        "chat_history": conversation_messages,
+        "context": docs_content,
+    })
+    return {"messages": [response]}

conversation/main.py

@@ -0,0 +1,79 @@
+from langchain.chat_models import init_chat_model
+from langchain_core.tools import tool
+from langchain_openai import OpenAIEmbeddings
+from langchain_qdrant import QdrantVectorStore
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import MessagesState, StateGraph, END
+from langgraph.prebuilt import ToolNode, tools_condition
+from langgraph.prebuilt import ToolNode
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams, SparseVectorParams
+
+from config import app_settings
+from conversation.generate import generate
+
+
+llm = init_chat_model(
+    app_settings.llm_model,
+    model_provider="openai",
+    api_key=app_settings.llm_api_key
+)
+
+embeddings = OpenAIEmbeddings(
+    model=app_settings.embedding_model,
+    api_key=app_settings.llm_api_key
+)
+
+client = QdrantClient(app_settings.vector_db_url)
+if not client.collection_exists(app_settings.vector_db_collection_name):
+    client.create_collection(
+        collection_name=app_settings.vector_db_collection_name,
+        vectors_config=VectorParams(size=app_settings.embedding_size, distance=Distance.COSINE),
+        sparse_vectors_config={'langchain-sparse': SparseVectorParams(index=None, modifier=None)}
+    )
+
+vector_store = QdrantVectorStore(
+    client=client,
+    collection_name=app_settings.vector_db_collection_name,
+    embedding=embeddings,
+)
+
+@tool(response_format="content_and_artifact")
+def retrieve(query: str):
+    """Retrieve information related to a query."""
+    retrieved_docs = vector_store.similarity_search(query, k=2)
+    serialized = "\n\n".join(
+        (f"Source: {doc.metadata}\n" f"Content: {doc.page_content}")
+        for doc in retrieved_docs
+    )
+    return serialized, retrieved_docs
+
+
+def query_or_respond(state: MessagesState):
+    """Generate tool call for retrieval or respond."""
+    llm_with_tools = llm.bind_tools([retrieve])
+    response = llm_with_tools.invoke(state["messages"])
+    # MessagesState appends messages to state instead of overwriting
+    return {"messages": [response]}
+
+
+graph_builder = StateGraph(MessagesState)
+tools = ToolNode([retrieve])
+memory = MemorySaver()
+
+graph_builder.add_node(query_or_respond)
+graph_builder.add_node(tools)
+graph_builder.add_node(generate)
+
+graph_builder.set_entry_point("query_or_respond")
+
+graph_builder.add_conditional_edges(
+    "query_or_respond",
+    tools_condition,
+    {END: END, "tools": "tools"},
+)
+
+graph_builder.add_edge("tools", "generate")
+graph_builder.add_edge("generate", END)
+
+graph = graph_builder.compile(checkpointer=memory)

ingestion/main.py

@@ -0,0 +1,41 @@
+import structlog
+
+from langchain_community.document_loaders import PDFPlumberLoader
+from langchain_openai import OpenAIEmbeddings
+from langchain_qdrant import QdrantVectorStore
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from qdrant_client import QdrantClient
+from qdrant_client.http.models import Distance, VectorParams, SparseVectorParams
+
+from config import app_settings
+
+logger = structlog.get_logger(__name__)
+
+# embeddings = OpenAIEmbeddings(
+#     model=app_settings.embedding_model,
+#     api_key=app_settings.llm_api_key
+# )
+
+# client = QdrantClient(app_settings.vector_db_url)
+# if not client.collection_exists(app_settings.vector_db_collection_name):
+#     client.create_collection(
+#         collection_name=app_settings.vector_db_collection_name,
+#         vectors_config=VectorParams(size=app_settings.embedding_size, distance=Distance.COSINE),
+#         sparse_vectors_config={'langchain-sparse': SparseVectorParams(index=None, modifier=None)}
+#     )
+# vector_store = QdrantVectorStore(
+#     client=client,
+#     collection_name=app_settings.vector_db_collection_name,
+#     embedding=embeddings,
+# )
+
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+
+def ingest_document(path, vector_store):
+    logger.info("Load document", path=path)
+    loader = PDFPlumberLoader(path)
+    docs = loader.load()
+    logger.info("Successfully loaded document", path=path)
+    all_splits = text_splitter.split_documents(docs)
+    _ = vector_store.add_documents(documents=all_splits)
+    logger.info("Successfully uploaded to vectorstore", path=path)

pyproject.toml

@@ -6,16 +6,25 @@ readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "gradio>=5.33.0",
+    "ipykernel>=6.29.5",
+    "langchain-community>=0.3.24",
+    "langchain-openai>=0.3.21",
+    "langchain-qdrant>=0.2.0",
+    "langchain-text-splitters>=0.3.8",
+    "langgraph>=0.4.8",
+    "pdfplumber>=0.11.6",
     "pydantic>=2.11.5",
     "pydantic-settings>=2.9.1",
+    "qdrant-client>=1.14.2",
     "structlog>=25.4.0",
 ]
 
 
 [tool.app_config]
 # shared
-llm_model = "gpt-4o"
-embedding_model = "BAAI/bge-m3"
+llm_model = "gpt-4o-mini"
+embedding_model = "text-embedding-3-large"
 embedding_url = "http://tei:80"
+embedding_size = 3072
 vector_db_url = ":memory:"
-vector_db_collection_name = "bgem3_store_multilingual"
+vector_db_collection_name = "test_collection"