changes in memory tool

app/persistance/memory_store_checkpointer_config.py

@@ -7,4 +7,7 @@ from app.utils.embeddings import remote_embeddings
 
 
 checkpointer = PostgresSaver(pool)
-memory_store = PostgresStore(pool, index={"dims": 384, "embed": remote_embeddings})
+memory_store = PostgresStore(pool, index={"dims": 384, "embed": remote_embeddings,"fields":["user_email_id","receiver_email_id","summary"]})
+
+
+

app/prompts/context_agent_prompt.py

@@ -1,27 +1,29 @@
 from langchain_core.messages import SystemMessage, HumanMessage,ToolMessage,AIMessage,BaseMessage
 from langchain_core.prompts import ChatPromptTemplate
 
+
 context_agent_template = ChatPromptTemplate([
     ("system", """
-ROLE: Situational Awareness Agent
-You are the lead Intelligence Officer for {user_name}. Your mission is to eliminate information asymmetry by synthesizing past interactions into a concise tactical brief.
+ROLE: Semantic & Fact Retrieval Specialist
+You are an expert context analyzer for {user_name}. Your primary task is to eliminate search noise by matching core semantic concepts and anchoring exact keyword facts from historical emails.
 
-TOOLS
-1. search_memory(query): Target the {senders_email} ↔ {user_email_id} loop.
-2. give_previous_context(memory_summary): Submit your synthesized findings.
+SEARCH STRATEGY:
+- Disregard the structural communication loop or mechanics.
+- Focus entirely on semantic alignment (intent, meanings, underlying topics).
+- Focus heavily on hard keyword facts (specific project names, technical acronyms, deadlines, numbers, and agreements).
 
-EXECUTION PROTOCOL
-- Pattern Recognition: Identify recurring project milestones, specific commitments, and unresolved friction points.
-- Sentiment Mapping: Analyze the historical tone (e.g., "Historically collaborative but currently urgent").
+EXECUTION PROTOCOL:
+- Semantic Alignment: Match historical conversations that touch on the exact concepts, challenges, or requests present in the incoming email.
+- Keyword Extraction: Pull out exact, unmutated entities (e.g., "Project Delta", "Q3 budget", "API contract") to maintain fact-based continuity.
 
-OUTPUT STRUCTURE
-- Current Brief: Tactical summary of the last relevant exchange.
-- Intelligence Points: Bulleted facts extracted from deep memory.
+OUTPUT STRUCTURE:
+- Core Semantic Context: A brief overview of what this ongoing topic means to the relationship.
+- Hard Intelligence Points: Bulleted, unmutated keyword facts, decisions, and dates extracted from deep memory.
 - Recommended Stance: Suggested tone (Formal/Casual/Direct) based on relationship history.
 
-CONSTRAINTS
-- Zero History: If no records exist, return: "No relevant past context found."
-- Minimalist: Do not explain your search process.
+CONSTRAINTS:
+- Zero History: If no records match semantically or factually, return: "No relevant past context found."
+- Noise Minimization: Do not narrate your search or reference your internal mechanics.
 """),
     ("human", """
 [INCOMING SIGNAL]
@@ -29,6 +31,6 @@ Sender: {senders_email}
 Topic: {subject}
 Body: {body}
 
-Action: Prepare situational brief.
+Action: Analyze semantic themes and key entities to extract a precise context brief.
 """),
-])
+])

app/tools/context_agent_tools.py

@@ -1,13 +1,63 @@
+from typing import Any
 from langmem import create_search_memory_tool
 from langchain.tools import tool
+from typing import Dict, Any
+from langchain.tools import tool
+from langgraph.prebuilt import InjectedState
+from langgraph.store.base import BaseStore
 
-search_memory_tool = create_search_memory_tool(
-    namespace=(
-        "email",
-        "{user_id}",
-        "collection"
+@tool
+def search_memory_tool(
+    query: str,
+    limit: int = 3,
+    # 1. Inject the entire Graph state at runtime
+    state: Dict[str, Any] = InjectedState, 
+    # 2. Inject the compiled graph storage layer
+    store: BaseStore = InjectedState("store") 
+) -> str:
+    """Search long-term memory for specific historical email contexts.
+    This tool automatically scopes the search to the active sender interaction.
+    """
+    
+    # Extract the runtime sender/receiver information directly from your graph state
+    # Replace keys with your exact LangGraph state schema keys (e.g., state.get("current_sender"))
+    active_user = state.get("user_id")
+    sender_email = state.get("sender_email_id") 
+    
+    # Fail gracefully if mandatory identification is missing in the state
+    if not sender_email:
+        return "Error: Cannot isolate history. Active sender_email_id is missing from state context."
+
+    # Formulate a strict metadata dictionary check matching your EmailMemory schema.
+    # We look for records where the communication partner matches the sender.
+    metadata_filter = {
+        "receiver_email_id": sender_email
+    }
+    
+    # Query your PostgresStore with explicit structural filters
+    results = store.search(
+        namespace=("email", active_user, "collection"),
+        query=query,
+        filter=metadata_filter,
+        limit=limit
     )
-)
+    
+    if not results:
+        return f"No prior email context found specifically for sender: {sender_email}."
+        
+    # Format structural outputs cleanly for your Context Agent
+    formatted_memories = []
+    for item in results:
+        val = item.value
+        formatted_memories.append(
+            f"--- Past Interaction Summary ---\n"
+            f"Sender: {val.get('user_email_id')}\n"
+            f"Receiver: {val.get('receiver_email_id')}\n"
+            f"Context Summary: {val.get('summary')}\n"
+        )
+        
+    return "\n".join(formatted_memories)
+
 
 @tool
 def give_previous_context(memory_summary: str) -> str:

requirements.txt

@@ -21,4 +21,6 @@ google-api-python-client
 langchain-google-community
 google-auth-oauthlib
 google-auth-httplib2
-bcrypt
+bcrypt
+
+