How I store agent response to local FAISS vector DB?

[mraguth]

In this code, I am losing the context as soon as I restart the kernel. Is that possible to store thread_1 response in local vector db? and retrieve it? Please help.

-----------------------------------------------------------
from langmem import create_manage_memory_tool, create_search_memory_tool
from langgraph.config import get_store
from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.store.memory import InMemoryStore

checkpointer = InMemorySaver()
store = InMemoryStore()


def chat(agent, txt, thread_id, user_id):
    result_state = agent.invoke({"messages": [{"role": "user", "content": txt}]}, 
                                config={"configurable": {"thread_id": thread_id, "user_id": user_id}})
    return result_state["messages"][-1].content

store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small"
    }
)

namespace = ("agent_memories",)
memory_tools = [
    create_manage_memory_tool(namespace),
    create_search_memory_tool(namespace)
]
checkpointer = InMemorySaver()

def prompt(state):
    # Search over memories based on the messages
    store = get_store()
    items = store.search(namespace, query=state["messages"][-1].content)
    memories = "\n\n".join(str(item) for item in items)
    system_msg = {"role": "system", "content": f"## Memories:\n\n{memories}"}
    return [system_msg] + state["messages"]
    
agent = create_react_agent(model, prompt=prompt, tools=memory_tools, store=store, checkpointer=checkpointer)


thread_1 = "thread-1"
chat(agent, "Hi there, I'm training for a half marathon in 2 months - could you propose a daily training plan to prepare?", thread_1, None)

print(chat(agent, "Nice! Wish me luck! Please note down the detailed memories for me :)", thread_1, None))

thread_2 = "thread-2"
chat(agent, "What I'm supposed to do for my training this week? It's week 5...", thread_2, None)

[dosubot[bot]]

To store the agent's response in a local FAISS vector database and retrieve it later, even after restarting the kernel, you can follow these steps:

1. Store the Response: Use the FAISS.from_texts method to create a FAISS index from the agent's responses. Save this index locally using the save_local method.

2. Retrieve the Response: After restarting the kernel, load the saved FAISS index using the load_local method to retrieve the stored responses.

Here's a code example demonstrating these steps:

import datetime
import tempfile
from langchain_community.vectorstores.faiss import FAISS
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings

# Step 1: Store the response
texts = ["agent response 1", "agent response 2", "agent response 3"]
docsearch = FAISS.from_texts(texts, FakeEmbeddings())

# Save the FAISS index locally
temp_timestamp = datetime.datetime.utcnow().strftime("%Y%m%d-%H%M%S")
with tempfile.TemporaryDirectory(suffix="_" + temp_timestamp + "/") as temp_folder:
    docsearch.save_local(temp_folder)

    # Step 2: Retrieve the response after restarting the kernel
    new_docsearch = FAISS.load_local(
        temp_folder, FakeEmbeddings(), allow_dangerous_deserialization=True
    )

# Now you can use `new_docsearch` to perform similarity searches
output = new_docsearch.similarity_search("agent response 1", k=1)
print(output)

This code snippet demonstrates how to store and retrieve agent responses using a FAISS vector database, ensuring persistence across kernel restarts ^[1][2].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[mraguth]

@dosu How I store below 'store' (code from above snippet) to local faiss vector db?

store = InMemoryStore()

[dosubot[bot]]

To store the store object from InMemoryStore to a local FAISS vector database, you can convert the data in InMemoryStore to a format suitable for FAISS, such as a list of texts, and then use the FAISS.from_texts method to create a FAISS index. Here's how you can do it:

1. Extract Data: Retrieve the data from InMemoryStore.
2. Create FAISS Index: Use FAISS.from_texts to create a FAISS index from the extracted data.
3. Save Locally: Use the save_local method to store the FAISS index locally.

Here's a code example:

import datetime
import tempfile
from langchain_community.vectorstores.faiss import FAISS
from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
from langchain.storage import InMemoryStore

# Step 1: Extract data from InMemoryStore
store = InMemoryStore()
store.mset([('key1', 'value1'), ('key2', 'value2')])
texts = [value for _, value in store.mget(['key1', 'key2']) if value is not None]

# Step 2: Create FAISS index
docsearch = FAISS.from_texts(texts, FakeEmbeddings())

# Step 3: Save the FAISS index locally
temp_timestamp = datetime.datetime.utcnow().strftime("%Y%m%d-%H%M%S")
with tempfile.TemporaryDirectory(suffix="_" + temp_timestamp + "/") as temp_folder:
    docsearch.save_local(temp_folder)

    # Load the FAISS index from the local directory
    new_docsearch = FAISS.load_local(
        temp_folder, FakeEmbeddings(), allow_dangerous_deserialization=True
    )

# Now 'new_docsearch' contains the FAISS index loaded from the local storage

This example demonstrates how to store data from InMemoryStore into a local FAISS vector database, ensuring persistence across sessions ^[1][2].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}