Added memory tool

app.py

@@ -2,6 +2,9 @@ import os, threading
 import gradio as gr
 from crew import run_crew
 from utils import get_questions
+from tools.memory_tools import memory_tool
+
+
 
 def ask(question, openai_api_key, gemini_api_key, anthropic_api_key, file_name = ""):
     """
@@ -152,3 +155,4 @@ with gr.Blocks() as grady:
 grady.launch(mcp_server=True)
 
 
+

crew.py

@@ -4,6 +4,7 @@
 # https://ai.google.dev/gemini-api/docs
 
 import os
+from tools.memory_tools import memory_tool
 from crewai import Agent, Crew, Task
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.project import CrewBase, agent, crew, task
@@ -150,26 +151,46 @@ class GAIACrew():
 
 
 def run_crew(question, file_path):
+    # 0) Prepend file data if needed
     final_question = question
-    
     if file_path:
-        if is_ext(file_path, ".csv") or is_ext(file_path, ".xls") or is_ext(file_path, ".xlsx") or is_ext(file_path, ".json") or is_ext(file_path, ".jsonl"):
+        if is_ext(file_path, ".csv") or is_ext(file_path, ".xls") \
+           or is_ext(file_path, ".xlsx") or is_ext(file_path, ".json") \
+           or is_ext(file_path, ".jsonl"):
             json_data = read_file_json(file_path)
             final_question = f"{question} JSON data:\n{json_data}."
         else:
             final_question = f"{question} File path: {file_path}."
 
+    # 1) Load memory (relevant recall)
+    history = memory_tool.run("load", question)
+    # In case some other implementation returns a list, handle it:
+    if isinstance(history, list):
+        history = "\n".join(history)
+
+    # 2) Build the prompt we send to Crew
+    #    If there is history, prefix it; otherwise just use the question
+    full_input = (history + "\n" if history else "") + final_question
+
+    # 3) Run the multi-agent Crew
     crew_instance = GAIACrew()
-    answer = crew_instance.get_crew().kickoff(inputs={"question": final_question})
-    final_answer = get_final_answer(FINAL_ANSWER_MODEL, question, str(answer))
+    raw_answer   = crew_instance.get_crew().kickoff(inputs={"question": full_input})
+
+    # 4) Save only the **user** question for future recall
+    memory_tool.run("save", question)
+
+    # 5) Post-process for the “final answer”
+    final_answer = get_final_answer(FINAL_ANSWER_MODEL, question, str(raw_answer))
+
+    # 6) (Optional) print debug traces
+    print(f"=> History:\n{history}")
+    print(f"=> Prompt sent:\n{full_input}")
+    print(f"=> Raw answer:\n{raw_answer}")
+    print(f"=> Final answer:\n{final_answer}")
 
-    print(f"=> Initial question: {question}")
-    print(f"=> Final question: {final_question}")
-    print(f"=> Initial answer: {answer}")
-    print(f"=> Final answer: {final_answer}")
-    
     return final_answer
 
+
 def get_final_answer(model, question, answer):
     prompt_template = """
         You are an expert question answering assistant. Given a question and an initial answer, your task is to provide the final answer.

faiss_index/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04bd4a34c4fb5c05840d6d26afa952c49bad6fd9e93951096a45584c4ad69dbb
+size 893

requirements.txt

@@ -1,10 +1,13 @@
 arize-phoenix-otel==0.10.1
-crewai==0.121.1
-crewai[tools]==0.121.1
-crewai-tools==0.45.0
+crewai
+crewai-tools
 google-genai==1.13.0
 gradio[mcp]==5.31.0
 openinference-instrumentation-crewai==0.1.10
 python-docx==1.1.2
 python-pptx==1.0.2
-stagehand-py==0.3.10
+stagehand-py==0.3.10
+langchain
+redis==4.5.5         # if you choose Redis for persistence
+python-dotenv        # to load REDIS_URL from .env
+faiss-cpu

tools/ai_tools.py

@@ -1,5 +1,6 @@
 import os
 
+from tools.memory_tools import memory_tool
 from crewai.tools import tool
 from crewai_tools import StagehandTool
 from google import genai

tools/memory_tools.py

@@ -0,0 +1,91 @@
+# tools/memory_tools.py
+
+import os
+from crewai.tools import tool
+from langchain.schema import Document
+from langchain.embeddings import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS   # faiss-cpu must be installed
+
+INDEX_DIR = "faiss_index"
+_embeddings = None   # will hold our OpenAIEmbeddings
+_vectorstore = None  # will hold our FAISS instance
+
+def _init_embeddings():
+    global _embeddings
+    if _embeddings is None:
+        _embeddings = OpenAIEmbeddings(
+            openai_api_key=os.environ.get("OPENAI_API_KEY", "")
+        )
+    return _embeddings
+
+def _load_or_build_index(doc: Document = None):
+    """
+    - If there's an in-memory index but the on-disk folder was removed, reset it.
+    - If there's an in-memory index and the folder still exists, reuse it.
+    - Else, if there's an on-disk index, load it.
+    - Else, if a single `doc` is provided, create a new index from it.
+    """
+    global _vectorstore
+    emb = _init_embeddings()
+
+    # 1) If we had an in-memory index but the INDEX_DIR was deleted, clear it so we rebuild
+    if _vectorstore is not None and not os.path.isdir(INDEX_DIR):
+        _vectorstore = None
+
+    # 2) If we now have an in-memory index, reuse it
+    if _vectorstore is not None:
+        return _vectorstore
+
+    # 3) On‐disk index?
+    if os.path.isdir(INDEX_DIR):
+        _vectorstore = FAISS.load_local(
+            INDEX_DIR, emb, allow_dangerous_deserialization=True
+        )
+        return _vectorstore
+
+    # 4) No index yet, but we're saving the first doc
+    if doc is not None:
+        _vectorstore = FAISS.from_documents([doc], emb)
+        _vectorstore.save_local(INDEX_DIR)
+        return _vectorstore
+
+    # 5) Otherwise, no index and no doc to build from
+    return None
+
+@tool("Memory Tool")
+def memory_tool(action: str, text: str) -> str:
+    """
+    action: "save" to store the user message, or "load" to retrieve similar past messages.
+    text:   the message to save, or the query for load.
+
+    Returns:
+      - on "save": "Saved"
+      - on "load": up to 3 similar messages joined by newline, or "" if none
+      - otherwise: "Invalid action"
+    """
+    act = action.strip().lower()
+
+    if act == "save":
+        # Wrap the text in a Document
+        doc = Document(page_content=text)
+
+        # Build or load the index (if it's the first doc, we pass it here)
+        vs = _load_or_build_index(doc)
+
+        # If we already had an index, just add the new doc
+        if vs and os.path.isdir(INDEX_DIR):
+            vs.add_documents([doc])
+            vs.save_local(INDEX_DIR)
+
+        return "Saved"
+
+    elif act == "load":
+        vs = _load_or_build_index()
+        if not vs:
+            return ""    # no history yet
+
+        hits = vs.similarity_search(text, k=3)
+        return "\n".join(d.page_content for d in hits)
+
+    else:
+        return "Invalid action"