Everything is working.

app.py

@@ -52,18 +52,20 @@ config = {"recursion_limit": 15, "configurable": {"thread_id": st.session_state.
 
 # Display chat messages from history on app rerun
 for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
+    with st.chat_message(message['role']):
+        st.markdown(message['content'])
 
 # React to user input
 if prompt := st.chat_input("What is your question?"):
     # Display user message in chat message container
     st.chat_message("user").markdown(prompt)
+    user_message = {"role": "user", "content": prompt}
     # Add user message to chat history
-    st.session_state.messages.append({"role": "user", "content": prompt})
+    st.session_state.messages.append(user_message)
 
     response = run_workflow(prompt, config)
     response_content = response.get("generation", "I'm sorry, I couldn't generate a response.")
+
     
     # Display assistant response in chat message container
     with st.chat_message("assistant"):

src/buildgraph.py

@@ -4,6 +4,7 @@ import sys
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.errors import GraphRecursionError
 
+
 memory = MemorySaver()
 
 try:
@@ -35,7 +36,7 @@ try:
             "greeting": "greeting",
             "route_question": "route_question",
         }
-    )
+)
 
     workflow.add_edge("greeting", END)
     workflow.add_edge("off_topic", END)
@@ -49,22 +50,12 @@ try:
         }   
     )
     
-    workflow.add_conditional_edges(
-        "retrieve",
-        check_recursion_limit,
-        {
-            "web_search": "web_search",
-            "continue": "grade_documents",
-        }
+    workflow.add_edge(
+        "retrieve", "grade_documents",
     )
     
-    workflow.add_conditional_edges(
-        "generate",
-        check_recursion_limit,
-        {
-            "web_search": "web_search",
-            "continue": "grade_generation",
-        }
+    workflow.add_edge(
+        "generate", "grade_generation",
     )
     
     workflow.add_conditional_edges(
@@ -136,48 +127,67 @@ except Exception as e:
     print(f"Error building the graph: {e}")
     sys.exit(1)
 
-def run_workflow(question, config):
+def run_workflow(user_input, config):
     try:
-        print(f"Running workflow for question: {question}")
-        
-        # Retrieve the previous state from memory
-        previous_state = memory.get(config)
-        
-        # Initialize the input state
+        print(f"Running workflow for question: {user_input}")
+
+        # Ensure user_input is a string, not a dict
+        if isinstance(user_input, dict):
+            print("user_input is a dict, extracting content")
+            user_input = user_input.get('content', str(user_input))
+
+        print(f"Processed user_input: {user_input}")
+
+        # Initialize input_state with required fields
         input_state = {
-            "question": question,
-            "chat_history": previous_state.get("chat_history", []) if previous_state else []
+            "messages": [{"role": "user", "content": user_input}]
         }
         
-        final_output = None
+        print(f"Initial input state: {input_state}")
+
         use_web_search = False
+        final_output = None
         
         try:
+            print("Starting graph execution")
             for output in app.stream(input_state, config):
+                # print(f"Graph output: {output}")
                 for key, value in output.items():
                     print(f"Node '{key}'")
                     if key in ["grade_generation", "off_topic", "greeting", "web_search"]:
+                        print(f"Setting final_output from node '{key}'")
                         final_output = value
+            print("Graph execution completed")
         except GraphRecursionError:
             print("Graph recursion limit reached, switching to web search")
             use_web_search = True
         
         if use_web_search:
-            # Force the use of web_search
+            print("Executing web search fallback")
             web_search_result = web_search(input_state)
+            print(f"Web search result: {web_search_result}")
             generate_result = generate(web_search_result)
+            print(f"Generate result: {generate_result}")
             final_output = generate_result
         
+        print(f"Final output before processing: {final_output}")
+        
         if final_output is None:
+            print("No final output generated")
             return {"generation": "I'm sorry, I couldn't generate a response. Could you please rephrase your question?"}
         elif isinstance(final_output, dict) and "generation" in final_output:
+            print("Final output is a dict with 'generation' key")
             return {"generation": str(final_output["generation"])}
         elif isinstance(final_output, str):
+            print("Final output is a string")
             return {"generation": final_output}
         else:
+            print(f"Unexpected final output type: {type(final_output)}")
             return {"generation": str(final_output)}
+
     except Exception as e:
         print(f"Error running the workflow: {e}")
+        print("Full traceback:")
         import traceback
         traceback.print_exc()
         return {"generation": "I encountered an error while processing your question. Please try again."}

src/graph.py

@@ -1,31 +1,48 @@
-from typing import List, Dict
+from typing import List, Dict, Optional
 from typing_extensions import TypedDict
 from src.websearch import *
 from src.llm import *
-from langchain.schema import Document, AIMessage
-from langgraph.errors import GraphRecursionError
+from langchain.schema import Document, AIMessage, HumanMessage, SystemMessage
+from typing import Annotated
+
+from typing_extensions import TypedDict
+
+from langgraph.graph.message import add_messages
+
 
 class GraphState(TypedDict):
-    question: str
-    generation: str
-    documents: List[str]
-    chat_history: List[Dict[str, str]]
+    messages: Annotated[List[Dict[str, str]], add_messages]
+    generation: Optional[str]
+    documents: Optional[List[Document]]
+    
+def serialize_messages(message):
+    """Convert messages to a JSON-compatible format."""
+    if isinstance(message, HumanMessage):
+        return {"role": "user", "content": message.content}
+    elif isinstance(message, AIMessage):
+        return {"role": "assistant", "content": message.content}
+    elif isinstance(message, SystemMessage):
+        return {"role": "system", "content": message.content}
+    else:
+        return {"role": "user", "content": message.content}
 
 def understand_intent(state):
     print("---UNDERSTAND INTENT---")
-    question = state["question"].lower()
-    chat_history = state.get("chat_history", [])
-    
-    # context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in chat_history[-2:]])
-    
-    intent = intent_classifier.invoke({"question": question})
-    print(f"Intent: {intent}")  # Debug print
-    return {"intent": intent, "question": question}
+    last_message = state["messages"][-1]
+    last_message = serialize_messages(last_message)
+    question = last_message.content if hasattr(last_message, 'content') else last_message["content"]
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(chat_context) for chat_context in chat_context]
+    chat_context = "\n".join([d.content if hasattr(d, 'content') else d["content"] for d in chat_context])
 
+    intent = intent_classifier.invoke({"question": question, "chat_context": chat_context})
+    print(f"Intent: {intent}")  # Debug print
+    return {
+        "intent": intent,
+        "messages": state["messages"]  # Return the messages to satisfy the requirement
+    }
 def intent_aware_response(state):
     print("---INTENT-AWARE RESPONSE---")
-    question = state["question"]
-    chat_history = state.get("chat_history", [])
     intent = state.get("intent", "")
     
     print(f"Responding to intent: {intent}")  # Debug print
@@ -51,54 +68,71 @@ def intent_aware_response(state):
 
 def retrieve(state):
     print("---RETRIEVE---")
-    question = state["question"]
-    documents = retriever.invoke(question)
-    return {"documents": documents, "question": question}
+    question = state["messages"][-1]
+    question = serialize_messages(question)
+    question = question.content if hasattr(question, 'content') else question["content"]
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(chat_context) for chat_context in chat_context]
+    chat_context = "\n".join([d.content if hasattr(d, 'content') else d["content"] for d in chat_context])
+
+    documents = retriever.invoke("Question: " + question + " Chat Context: " + chat_context)
+    print("---RETRIEVED---")
+    return {"documents": documents}
 
 def generate(state):
     print("---GENERATE---")
-    question = state["question"]
-    documents = state["documents"]
-    chat_history = state.get("chat_history", [])
-
-    context = "\n".join([doc.page_content for doc in documents])
-    chat_context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in chat_history[-5:]])
-
-    generation_prompt = f"""
-    As LegalAlly, an AI assistant specializing in the Indian Penal Code, provide a helpful and informative response to the following question. Use the given context and chat history for reference.
-    Responses are concise and answer user's queries directly. They are not verbose. The answer feels natural and not robotic.
-    Make sure the answer is grounded in the documents and is not hallucination.
-
-    Context:
-    {context}
-
-    Chat History:
-    {chat_context}
+    print("state: ", state)
+    
+    if "messages" not in state or not state["messages"]:
+        return {"generation": "I'm sorry, I don't have enough context to generate a response. Could you please try asking your question again?"}
 
-    Question: {question}
+    question = state["messages"][-1]
+    if isinstance(question, dict):
+        question_content = question.get("content", "")
+    else:
+        question = serialize_messages(question)
+        question_content = question.get("content", "")
 
-    Response:
-    """
+    chat_context = state["messages"][-3:]
+    chat_context = [
+        serialize_messages(msg) if not isinstance(msg, dict) else msg 
+        for msg in chat_context
+    ]
+    chat_context = "\n".join([d.get("content", "") for d in chat_context])
     
-    generation = llm.invoke(generation_prompt)
-    generation = generation.content if hasattr(generation, 'content') else str(generation)
+    documents = state.get("documents", [])
     
-    return {
-        "documents": documents,
-        "question": question,
-        "generation": generation,
-        "chat_history": chat_history + [{"role": "human", "content": question}, {"role": "ai", "content": generation}]
-    }
+    if isinstance(documents, Document):
+        context = documents.page_content
+    else:
+        context = "\n".join([doc.page_content for doc in documents])
+
+    generation_prompt = [
+        {"role": "system", "content": "You are a helpful AI assistant specializing in the Indian Penal Code. Provide a concise, medium length and accurate answer based on the given context and question."},
+        {"role": "user", "content": f"Knowledge Base: {context}\n\nQuestion: {question_content}\n\n Chat Context: {chat_context}. Keep the answer relevant to the question. Provide a detailed answer only if user specifically asks for it."}
+    ]
+    
+    try:
+        generation = llm.invoke(generation_prompt)
+        return {"generation": generation.content}
+    except Exception as e:
+        print(f"Error in generate function: {e}")
+        return {"generation": "I'm sorry, I encountered an error while generating a response. Could you please try again?"}
 
 def grade_documents(state):
     print("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
-    question = state["question"]
-    documents = state["documents"]
+    question = state["messages"][-1]
+    question = serialize_messages(question)
+    question = question.content if hasattr(question, 'content') else question["content"]
+    documents = state.get("documents", [])
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(chat_context) for chat_context in chat_context]
+    chat_context = "\n".join([d.content if hasattr(d, 'content') else d["content"] for d in chat_context])
 
     filtered_docs = []
     for d in documents:
         score = retrieval_grader.invoke(
-            {"question": question, "document": d.page_content}
+            {"question": question, "document": d.page_content, "chat_context": chat_context}
         )
         grade = score.binary_score
         if grade == "yes":
@@ -107,21 +141,44 @@ def grade_documents(state):
         else:
             print("---GRADE: DOCUMENT NOT RELEVANT---")
             continue
-    return {"documents": filtered_docs, "question": question}
+    return {"documents": filtered_docs}
 
 def transform_query(state):
     print("---TRANSFORM QUERY---")
-    question = state["question"]
-    documents = state["documents"]
+    question = state["messages"][-1]
+    question = serialize_messages(question)
+    question = question.content if hasattr(question, 'content') else question["content"]
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(chat_context) for chat_context in chat_context]
+    chat_context = "\n".join([d.content if hasattr(d, 'content') else d["content"] for d in chat_context])
+    documents = state.get("documents", [])
 
-    better_question = question_rewriter.invoke({"question": question})
-    return {"documents": documents, "question": better_question}
+    better_question = question_rewriter.invoke({"question": question, "chat_context": chat_context})
+    print(f"Better question: {better_question}")
+    transformed_query = {
+        "role": "user",
+        "content": better_question
+    }
+    
+    # Append the tool message to the state's memory
+    state["messages"][-1] = transformed_query
+    
+    return {"documents": documents}
 
 def web_search(state):
     print("---WEB SEARCH---")
-    question = state["question"]
+    question = state["messages"][-1]
+    if isinstance(question, dict):
+        question = question.get("content", "")
+    else:
+        question = serialize_messages(question)
+        question = question.get("content", "")
 
-    web_results = web_search_tool.invoke({"query": question})
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(msg) if not isinstance(msg, dict) else msg for msg in chat_context]
+    chat_context = "\n".join([d.get("content", "") for d in chat_context])
+    
+    web_results = web_search_tool.invoke({"query": question, "chat_context": chat_context})
     
     if isinstance(web_results, str):
         web_results = [{"content": web_results}]
@@ -133,51 +190,48 @@ def web_search(state):
     web_content = "\n".join([d["content"] for d in web_results])
     web_document = Document(page_content=web_content)
 
-    return {"documents": [web_document], "question": question}
+    return {
+        "documents": web_document,
+        "messages": state["messages"]
+    }
 
 def route_question(state):
-    """
-    Route question to web search or RAG.
-
-    Args:
-        state (dict): The current graph state
-
-    Returns:
-        dict: Updated state with routing information
-    """
-
     print("---ROUTE QUESTION---")
-    question = state["question"]
-    source = question_router.invoke({"question": question})
+    question = state["messages"][-1]
+    if isinstance(question, dict):
+        question = question.get("content", "")
+    else:
+        question = serialize_messages(question)
+        question = question.get("content", "")
+
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(msg) if not isinstance(msg, dict) else msg for msg in chat_context]
+    chat_context = "\n".join([d.get("content", "") for d in chat_context])
     
+    source = question_router.invoke({"question": question, "chat_context": chat_context})
+    
+    result = {}
     if source.datasource == "web_search":
         print("---ROUTE QUESTION TO WEB SEARCH---")
-        return {
-            "route_question": "web_search",
-            "question": question  # Maintain the current question
-        }
+        result["route_question"] = "web_search"
     elif source.datasource == "vectorstore":
         print("---ROUTE QUESTION TO RAG---")
-        return {
-            "route_question": "vectorstore",
-            "question": question  # Maintain the current question
-        }
+        result["route_question"] = "vectorstore"
     else:
         print("---UNKNOWN ROUTE, DEFAULTING TO RAG---")
-        return {
-            "route_question": "vectorstore",
-            "question": question  # Maintain the current question
-        }
+        result["route_question"] = "vectorstore"
+    
+    # Ensure we're returning at least one of the required keys
+    result["messages"] = state["messages"]
+    
+    return result
 
 def decide_to_generate(state):
     print("---ASSESS GRADED DOCUMENTS---")
-    state["question"]
-    filtered_documents = state["documents"]
+    filtered_documents = state.get("documents", [])
 
     if not filtered_documents:
-        print(
-            "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---"
-        )
+        print("---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---")
         return "transform_query"
     else:
         print("---DECISION: GENERATE---")
@@ -185,62 +239,56 @@ def decide_to_generate(state):
 
 def grade_generation_v_documents_and_question(state):
     print("---CHECK HALLUCINATIONS---")
-    question = state["question"]
-    documents = state["documents"]
+    question = state["messages"][-1]
+    question = serialize_messages(question)
+    question = question.content if hasattr(question, 'content') else question["content"]
+    chat_context = state["messages"][-3:]
+    chat_context = [serialize_messages(chat_context) for chat_context in chat_context]
+    chat_context = "\n".join([d.content if hasattr(d, 'content') else d["content"] for d in chat_context])
+    documents = state.get("documents", [])
     generation = state["generation"]
-    chat_history = state.get("chat_history", [])
 
     score = hallucination_grader.invoke(
-        {"documents": documents, "generation": generation}
+        {"documents": documents, "generation": generation, "chat_context": chat_context}
     )
     grade = score.binary_score
 
     if grade == "yes":
         print("---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---")
-        score = answer_grader.invoke({"question": question, "generation": generation})
+        score = answer_grader.invoke({"question": question, "generation": generation, "chat_context": chat_context})
         grade = score.binary_score
         if grade == "yes":
             print("---DECISION: GENERATION ADDRESSES QUESTION---")
             return {
                 "grade_generation": "useful",
-                "question": question,
                 "generation": generation,
                 "documents": documents,
-                "chat_history": chat_history
             }
         else:
             print("---DECISION: GENERATION DOES NOT ADDRESS QUESTION---")
             return {
                 "grade_generation": "not useful",
-                "question": question,
                 "generation": generation,
                 "documents": documents,
-                "chat_history": chat_history
             }
     else:
         print("---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---")
         return {
             "grade_generation": "not supported",
-            "question": question,
             "generation": generation,
             "documents": documents,
-            "chat_history": chat_history
         }
 
 def greeting(state):
     print("---GREETING---")
+    
     return {
-        "generation": "Hello! I'm LegalAlly, an AI assistant specializing in Indian law, particularly the Indian Penal Code and Indian Constitution. How can I assist you today?"
+        "generation": "Hello! I'm LegalAlly, an AI assistant specializing in Indian law, particularly the Indian Penal Code and Indian Constitution. How can I assist you today?",
     }
 
 def off_topic(state):
     print("---OFF-TOPIC---")
     return {
-        "generation": "I apologize, but I specialize in matters related to the Indian Penal Code. Could you please ask a question about Indian law or legal matters?"
+        "generation": "I apologize, but I specialize in matters related to the Indian Penal Code. Could you please ask a question about Indian law or legal matters?",
     }
 
-# conditional edges for recursion limit
-def check_recursion_limit(state):
-    # LangGraph will automatically raise GraphRecursionError if the limit is reached
-    # We don't need to check for it explicitly
-    return "continue"

src/index.py

@@ -61,7 +61,7 @@ try:
 
     print("Splitting documents...")
     text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
-        chunk_size=500, chunk_overlap=100
+        chunk_size=300, chunk_overlap=100
     )
     doc_splits = text_splitter.split_documents(docs)
     print(f"Documents split into {len(doc_splits)} chunks.")
@@ -102,7 +102,7 @@ try:
         )
         print("Existing vector store loaded.")
 
-    retriever = vectorstore.as_retriever()
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 10, "score_threshold": 0.6}, search_type="similarity_score_threshold")
     print("Retriever set up successfully.")
 except Exception as e:
     print(f"Error with vector store operations: {e}")

src/llm.py

@@ -36,6 +36,7 @@ route_prompt = ChatPromptTemplate.from_messages(
     [
         ("system", system),
         ("human", "{question}"),
+        ("human", "{chat_context}"),
     ]
 )
 
@@ -58,13 +59,15 @@ structured_llm_grader = llm.with_structured_output(GradeDocuments)
 
 # Prompt
 system = """You are a grader assessing relevance of a retrieved document to a user question. \n 
-    If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \n
-    It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \n
-    Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question."""
+    If the document contains keyword(s) or is relevant to the user question, grade it as relevant. \n
+    The goal is to filter out erroneous retrievals. \n
+    Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.
+    Return 'yes' if the document is relevant to the question, otherwise return 'no'.
+    Also return 'yes' if the document may be relevant, and might be useful, otherwise return 'no'."""
 grade_prompt = ChatPromptTemplate.from_messages(
     [
         ("system", system),
-        ("human", "Retrieved document: \n\n {document} \n\n User question: {question}"),
+        ("human", "Retrieved document: \n\n {document} \n\n User question: {question} \n\n Chat context: {chat_context}"),
     ]
 )
 
@@ -125,7 +128,7 @@ system = """You are a grader assessing whether an LLM generation is grounded in
 hallucination_prompt = ChatPromptTemplate.from_messages(
     [
         ("system", system),
-        ("human", "Set of facts: \n\n {documents} \n\n LLM generation: {generation}"),
+        ("human", "Set of facts: \n\n {documents} \n\n LLM generation: {generation} \n\n Chat context: {chat_context}"),
     ]
 )
 
@@ -155,7 +158,7 @@ system = """You are a grader assessing whether an answer addresses / resolves a
 answer_prompt = ChatPromptTemplate.from_messages(
     [
         ("system", system),
-        ("human", "User question: \n\n {question} \n\n LLM generation: {generation}"),
+        ("human", "User question: \n\n {question} \n\n LLM generation: {generation} \n\n Chat context: {chat_context}"),
     ]
 )
 
@@ -176,7 +179,7 @@ re_write_prompt = ChatPromptTemplate.from_messages(
         ("system", system),
         (
             "human",
-            "Here is the initial question: \n\n {question} \n Formulate an improved question.",
+            "Here is the initial question: \n\n {question} \n\n Here is the chat context: \n\n {chat_context} \n. Use it to form a better question. Formulate an improved question.",
         ),
     ]
 )
@@ -189,7 +192,11 @@ class IntentClassifier(BaseModel):
 
     intent: Literal["greeting", "legal_query", "follow_up", "off_topic"] = Field(
         ...,
-        description="Classify the intent of the user query. 'greeting' if the user is saying greetings, 'legal_query' if the user is asking for information about law, 'follow_up' if the user is asking for information related to the previous conversation, 'off_topic' if the user is asking for information about anything else.",
+        description="""Classify the intent of the user query.
+        'greeting' if the user is saying greetings,
+        'legal_query' if the user is asking for information about law,
+        'follow_up' if the user is asking for information related to the previous conversation. If you think the user is referring to a previous conversation, you can classify it as 'follow_up'.
+        'off_topic' if the user is asking for information about anything else."""
     )
 
 # LLM with function call
@@ -202,7 +209,7 @@ system = """You are an intent classifier that classifies the intent of a user qu
 intent_classifier_prompt = ChatPromptTemplate.from_messages(
     [
         ("system", system),
-        ("human", "Here is the user query: \n\n {question} \n\n Classify the intent of the user query."),
+        ("human", "Here is the user query: \n\n {question} \n\n Here is the chat context: \n\n {chat_context} \n\n Classify the intent of the user query."),
     ]
 )
 

vectordb/{65ba2328-ffa1-497d-b641-c6b84db7f0e1 → 6013b6fb-1b7b-4130-807d-3a6eda24f832}/data_level0.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f18abd8c514282db82706e52b0a33ed659cd534e925a6f149deb7af9ce34bd8e
+oid sha256:ed70a67cc0528f917f4ccb2fb46c1d741f6c05ce2926c8886dec011a3a6cbd36
 size 6284000

vectordb/{65ba2328-ffa1-497d-b641-c6b84db7f0e1 → 6013b6fb-1b7b-4130-807d-3a6eda24f832}/header.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:effaa959ce2b30070fdafc2fe82096fc46e4ee7561b75920dd3ce43d09679b21
+oid sha256:db7283591f6d2aad4bb6a45bcfa80ec72d570df15bb49d9bab746044ad5b8ed5
 size 100

vectordb/6013b6fb-1b7b-4130-807d-3a6eda24f832/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f4a936b6640d95fbbd3a09052107a5b6c37d981d529dc515d33ab747bc4d256
+size 55974

vectordb/{65ba2328-ffa1-497d-b641-c6b84db7f0e1 → 6013b6fb-1b7b-4130-807d-3a6eda24f832}/length.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8e2f111e5a36cc65e03a6865c3705bf32a17689ff8658620547a6164df6dff14
+oid sha256:314fb0b4e346724692db2ea70ef50682c05bf730c753fd4d8bda50e14374c304
 size 4000

vectordb/6013b6fb-1b7b-4130-807d-3a6eda24f832/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:284b621f3a4662e0480134404f4716ca28e51490f424b7243a7e022c2369dfc0
+size 8420

vectordb/chroma.sqlite3

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aab4817b7e371b5ddea619c2acb598da4c22f8b8a47e32fd84528a50018b8668
-size 13512704
+oid sha256:22346c5576728629810eb17f18ccdb39941f1db4e1c49aa6997f9e6fd298c10c
+size 18862080