fix: memory store issue

conversation_memory.py

@@ -2,27 +2,27 @@ import json
 import os
 class ConversationMemory:
     def __init__(self):
-        self.history = []  # All parsed steps from all requests
         self.tools_used = []
         self.all_queries = []
         self.query_results = []
-        self.user_messages = []
+        self.request = []
 
-    def update_from_parsed(self, parsed_steps):
+    def update_from_parsed(self, parsed_steps, request):
         tools = []
+        self.request.append(request)
         for step in parsed_steps:
-            if step['type'] == 'user_message':
-                self.user_messages.append(step['content'])
-            elif step['type'] == 'ai_function_call':
+            if step['type'] == 'ai_function_call':
                 tools.append(step['tool'])
                 if 'query' in step:
                     self.all_queries.append(step['query'])
+            elif step['type'] == 'ai_final_answer':
+                if 'query' in step['ai_said'][0]:
+                    self.all_queries.append(step['ai_said'][1])
             elif step['type'] == 'tool_response':
                 if step['tool'] == 'execute_query':
                     self.query_results.append(step['response'])
 
         self.tools_used.extend(tools)
-        self.history.append(parsed_steps)
 
     def get_last_n_queries(self):
         return list(set(self.all_queries))
@@ -34,7 +34,7 @@ class ConversationMemory:
         return list(set(self.tools_used))
 
     def get_all_user_messages(self):
-        return list(set(self.user_messages))
+        return list(set(self.request))
 
     def reset(self, path = "memory.json"):
         os.remove(path)
@@ -42,9 +42,9 @@ class ConversationMemory:
 
     def summary(self):
         return {
-            "total_requests": len(self.user_messages),
+            "total_requests": len(self.request),
             "tools_used": self.get_all_tools_used(),
-            "last_request": self.user_messages[-1] if self.user_messages else None,
+            "last_request": self.request[-1] if self.request else None,
             "last_query": self.all_queries[-1] if self.all_queries else None,
             "last_result": self.query_results[-1] if self.query_results else None,
         }

postgre_mcp_client.py

@@ -1,4 +1,6 @@
 import asyncio
+import os.path
+
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
@@ -22,9 +24,11 @@ The users table stores information about the individuals who use the application
 The posts table represents content created by users, such as blog posts or messages. Like the users table, each entry has a unique, auto-incrementing id as the primary key. The user_id field links each post to its author by referencing the id field in the users table, establishing a one-to-many relationship between users and posts. The title column holds a brief summary or headline of the post, while the content field contains the full text. A created_at timestamp is also included to record when each post was created, with a default value of the current time.
 """
 
-request = "can you show me the result of the join of all tables?"
-request2 = "how many columns are there in this joined table?"
-request3 = "send the last table"
+#request = "can you show me the result of the join of postes and users tables?"
+#request = "May ı see the table?"
+#request = "stop"
+#request = "how many columns are there in this joined table?"
+request = "send the table"
 async def main():
     async with stdio_client(server_params) as (read, write):
         async with ClientSession(read, write) as session:
@@ -38,11 +42,19 @@ async def main():
             for tool in tools:
                 tool.description += f" {table_summary}"
 
-            memory = memory.load_memory()
-            past_tools = memory.get_all_tools_used()
-            past_queries = memory.get_last_n_queries()
-            past_results = memory.get_last_n_results()
-            past_requests = memory.get_all_user_messages()
+            if os.path.exists("memory.json"):
+                memory = memory.load_memory()
+                past_tools = memory.get_all_tools_used()
+                past_queries = memory.get_last_n_queries()
+                past_results = memory.get_last_n_results()
+                past_requests = memory.get_all_user_messages()
+
+            else:
+                past_tools = "No tools found"
+                past_queries ="No queries found"
+                past_results = "No results found"
+                past_requests = "No requests found"
+
 
             intent = classify_intent(request)
 
@@ -56,7 +68,8 @@ async def main():
                     past_tools=past_tools,
                     last_queries=past_queries,
                     last_results=past_results,
-                    new_request=request3
+                    new_request=request
+
                 )
 
             else:
@@ -73,7 +86,7 @@ async def main():
                     past_tools=past_tools,
                     last_queries=past_queries,
                     last_results=past_results,
-                    new_request = request2,
+                    new_request = request,
                     tools = tools_str
                 )
 
@@ -85,9 +98,9 @@ async def main():
 
 
             parsed_steps, query_store = parse_mcp_output(agent_response)
-
-
-            memory.update_from_parsed(parsed_steps)
+            print("************")
+            print(parsed_steps)
+            memory.update_from_parsed(parsed_steps, request)
 
             if request.strip().lower() == "stop":
                 memory.reset()

postgre_mcp_server.py

@@ -69,6 +69,7 @@ async def base_prompt_query() -> str:
                     - Retrieve schema details
                     - Execute SQL queries
 
+
                     Each tool may also return previews or summaries of table contents to help you better understand the data structure.
 
                     You also have access to **short-term memory**, which stores relevant context from earlier queries. If memory contains the needed information, you **must use it** instead of repeating tool calls with the same input. Avoid redundant tool usage unless:
@@ -86,9 +87,10 @@ async def base_prompt_query() -> str:
                     1. Analyze the request to determine the desired data or action.
                     2. Use tools to gather any necessary information (e.g., list tables, get schema).
                     3. Generate a valid SQL query (such as **SELECT**, **COUNT**, or other read-only operations) and clearly display the full query.
-                    4. Execute the query and return the result.
-                    5. Chain tools logically to build toward the answer.
+                    4. Execute the query and **return the result**.
+                    5. **Chain tools logically to build toward the answer.**
                     6. Explain your reasoning at every step for clarity and transparency.
+                    7. Show the result of the **execute_query** in your final answer. 
 
                     ---
 
@@ -102,6 +104,8 @@ async def base_prompt_query() -> str:
                     - Validate SQL syntax before execution.
                     - Never assume table or column names. Use tools to confirm structure.
                     - Use memory efficiently. Don’t rerun a tool unless necessary.
+                    - If you generate a SQL query, you **have to** use **execute_query** tool at the end.
+
 
                     ---
 
@@ -141,6 +145,14 @@ async def base_prompt_query() -> str:
                        ```sql
                        SELECT product_name, SUM(total_sales) FROM sales_data GROUP BY product_name;
 
+                    ### Example 1 — Repeating the same request:
+                    **User Request:** "Get the total sales for each product."
+                    **Steps:**
+                    1. Use memory to check if we already retrieved schema.
+                    2. Retrieve the SQL query that gives the total sales for each product.
+                    3. Only execute the query and show the user. 
+
+
                     ### Example 2 — Schema Uncertainty:
                     **User Request:** "Show customer emails from the database."
 
@@ -152,6 +164,7 @@ async def base_prompt_query() -> str:
                        ```sql
                        SELECT email FROM customers;
 
+
                     ### Example 3 — Memory Usage:
                     **User Request:** "Get top 5 most expensive products."
 
@@ -161,6 +174,7 @@ async def base_prompt_query() -> str:
                        ```sql
                        SELECT * FROM products ORDER BY price DESC LIMIT 5;
 
+
                     ### Example 4 — COUNT Query:
                     **User Request:** "How many orders have been placed?"
 
@@ -171,6 +185,7 @@ async def base_prompt_query() -> str:
                        ```sql
                        SELECT COUNT(*) FROM orders;
 
+
                     ### Example 5 — WHERE Clause (Filtering):
                     **User Request:** "Get the names of customers from Germany."
 
@@ -181,6 +196,7 @@ async def base_prompt_query() -> str:
                        ```sql
                        SELECT name FROM customers WHERE country = 'Germany';
 
+
                     ## Example 6 — Basic Aggregation**
                     **User Request:** "Get total sales for each product"
 
@@ -190,6 +206,7 @@ async def base_prompt_query() -> str:
                     ```sql
                     SELECT product_name, SUM(total_sales) FROM sales_data GROUP BY product_name;
 
+
                     ### Invalid Example — DELETE Operation (Not Allowed):
                     **User Request:** "Delete all customers from Germany."
 

utils.py

@@ -67,13 +67,6 @@ def parse_mcp_output(output_dict):
                 "response": content
             })
 
-        elif role_name == "HumanMessage":
-            result.append({
-                "type": "user_message",
-                "content": content
-            })
-
-
     return result, query_store