feat: convertion memory

conversation_memory.py

@@ -0,0 +1,62 @@
+import json
+
+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 = []
+
+    def update_from_parsed(self, parsed_steps):
+        tools = []
+        for step in parsed_steps:
+            if step['type'] == 'user_message':
+                self.user_messages.append(step['content'])
+            elif step['type'] == 'ai_function_call':
+                tools.append(step['tool'])
+                if 'query' in step:
+                    self.all_queries.append(step['query'])
+            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))
+
+    def get_last_n_results(self):
+        return list(set(self.query_results))
+
+    def get_all_tools_used(self):
+        return list(set(self.tools_used))
+
+    def get_all_user_messages(self):
+        return list(set(self.user_messages))
+
+    def reset(self):
+        self.__init__()  # Re-initialize the object
+
+    def summary(self):
+        return {
+            "total_requests": len(self.user_messages),
+            "tools_used": self.get_all_tools_used(),
+            "last_request": self.user_messages[-1] if self.user_messages 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,
+        }
+
+    def save_memory(self, path="memory.json"):
+        with open(path, "w") as f:
+            json.dump(self.__dict__, f)
+
+    def load_memory(self, path="memory.json"):
+        try:
+            with open(path, "r") as f:
+                data = json.load(f)
+            self.__dict__.update(data)
+            return self
+        except FileNotFoundError:
+            return ConversationMemory()

memory.json

@@ -0,0 +1 @@
+{"history": [[{"type": "user_message", "content": "=========================\n# Your Role\n=========================\n\nYou are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:\n\n- List available tables\n- Retrieve schema details\n- Execute SQL queries\n\nEach tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.\n\n=========================\n# Your Objective\n=========================\n\nWhen a user submits a request, you must:\n\n1. **Analyze the request** to determine the required data or action.\n2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).\n3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.\n4. **Execute the SQL query** and return the results.\n5. **Chain tools logically**, such as: List Tables \u2192 Get Schema \u2192 Write and Run Query.\n6. **Explain your reasoning and each step taken** to ensure clarity and transparency.\n\n=========================\n# Critical Rules\n=========================\n\n- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).\n- Always display any SQL query you generate along with the result of its execution.\n- Validate SQL syntax before execution to ensure correctness and safety.\n- Never make assumptions about the database structure \u2014 always use tools to confirm table and column names.\n- Be cautious, deliberate, and transparent in your actions.\n\n=========================\n# Short-Term Memory\n=========================\n\nYou have access to the following memory from this conversation. Use it if applicable for the current request.\n\n### Conversation Context:\n- **Previous user requests**:\n  []\n- **Tools used so far**:\n  []\n- **Last SQL queries (if any)**:\n  []\n- **Last result preview**:\n  []\n\n=========================\n# New User Request\n=========================\n\nPlease fulfill the following request based on the above context:\n\ncan you show me the result of the join of all tables?\n"}, {"type": "ai_function_call", "ai_said": "Okay, I will attempt to join all tables and show the results. Here's the plan:\n\n1.  **List tables:** I'll start by listing the tables in the database to know which tables are available.\n2.  **Get schema:** I'll retrieve the schema of each table to understand their structure and identify potential join columns.\n3.  **Construct and execute the SQL query:** Based on the table schemas, I will construct a SQL query to join the tables. Since there is no information about the relationships between tables, I will try to join them based on common columns like 'id' and table names. I will then execute the query.\n\nLet's start by listing the tables.", "tool": "list_tables", "args": "{}"}, {"type": "tool_response", "tool": "list_tables", "response": "posts\nusers"}, {"type": "ai_function_call", "ai_said": "Okay, I see two tables: \"posts\" and \"users\". I will now retrieve the schema of both tables to understand their structure and identify potential join columns.", "tool": "get_table_schema", "args": "{\"table_name\": \"users\"}"}, {"type": "tool_response", "tool": "get_table_schema", "response": "Table: posts\nColumns:\n- id (integer) NOT NULL DEFAULT nextval('posts_id_seq'::regclass)\n- user_id (integer) NULL\n- title (character varying(200)) NULL\n- content (text) NULL\n- created_at (timestamp without time zone) NULL DEFAULT CURRENT_TIMESTAMP"}, {"type": "tool_response", "tool": "get_table_schema", "response": "Table: users\nColumns:\n- id (integer) NOT NULL DEFAULT nextval('users_id_seq'::regclass)\n- username (character varying(100)) NOT NULL\n- email (character varying(100)) NOT NULL\n- created_at (timestamp without time zone) NULL DEFAULT CURRENT_TIMESTAMP"}, {"type": "ai_function_call", "ai_said": ["Okay, I need to join the `posts` and `users` tables. Based on the schema, the `posts` table has a `user_id` column that likely references the `id` column in the `users` table. I will construct a query to join these tables on the `user_id` and `id` columns.\n\nHere's the SQL query:", "```sql\nSELECT *\nFROM posts\nJOIN users ON posts.user_id = users.id;\n```", "\n\nNow, I will execute the query."], "tool": "execute_query", "args": "{\"query\": \"SELECT * FROM posts JOIN users ON posts.user_id = users.id;\"}"}, {"type": "tool_response", "tool": "execute_query", "response": "id | user_id | title | content | created_at | id | username | email | created_at\n--------------------------------------------------------------------------------\n1 | 1 | Hello World | This is my first post! | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107\n2 | 2 | Bob\u2019s Thoughts | Here are some thoughts... | 2025-04-09 11:16:04.846107 | 2 | bob | bob@example.com | 2025-04-09 11:16:04.846107\n3 | 1 | Follow-up Post | Another one from Alice. | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107"}, {"type": "ai_final_answer", "ai_said": "I have successfully joined the `posts` and `users` tables on the `user_id` and `id` columns, respectively, and displayed the results."}], [{"type": "user_message", "content": "=========================\n# Your Role\n=========================\n\nYou are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:\n\n- List available tables\n- Retrieve schema details\n- Execute SQL queries\n\nEach tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.\n\n=========================\n# Your Objective\n=========================\n\nWhen a user submits a request, you must:\n\n1. **Analyze the request** to determine the required data or action.\n2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).\n3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.\n4. **Execute the SQL query** and return the results.\n5. **Chain tools logically**, such as: List Tables \u2192 Get Schema \u2192 Write and Run Query.\n6. **Explain your reasoning and each step taken** to ensure clarity and transparency.\n\n=========================\n# Critical Rules\n=========================\n\n- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).\n- Always display any SQL query you generate along with the result of its execution.\n- Validate SQL syntax before execution to ensure correctness and safety.\n- Never make assumptions about the database structure \u2014 always use tools to confirm table and column names.\n- Be cautious, deliberate, and transparent in your actions.\n\n=========================\n# Short-Term Memory\n=========================\n\nYou have access to the following memory from this conversation. Use it if applicable for the current request.\n\n### Conversation Context:\n- **Previous user requests**:\n  ['=========================\\n# Your Role\\n=========================\\n\\nYou are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:\\n\\n- List available tables\\n- Retrieve schema details\\n- Execute SQL queries\\n\\nEach tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.\\n\\n=========================\\n# Your Objective\\n=========================\\n\\nWhen a user submits a request, you must:\\n\\n1. **Analyze the request** to determine the required data or action.\\n2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).\\n3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.\\n4. **Execute the SQL query** and return the results.\\n5. **Chain tools logically**, such as: List Tables \u2192 Get Schema \u2192 Write and Run Query.\\n6. **Explain your reasoning and each step taken** to ensure clarity and transparency.\\n\\n=========================\\n# Critical Rules\\n=========================\\n\\n- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).\\n- Always display any SQL query you generate along with the result of its execution.\\n- Validate SQL syntax before execution to ensure correctness and safety.\\n- Never make assumptions about the database structure \u2014 always use tools to confirm table and column names.\\n- Be cautious, deliberate, and transparent in your actions.\\n\\n=========================\\n# Short-Term Memory\\n=========================\\n\\nYou have access to the following memory from this conversation. Use it if applicable for the current request.\\n\\n### Conversation Context:\\n- **Previous user requests**:\\n  []\\n- **Tools used so far**:\\n  []\\n- **Last SQL queries (if any)**:\\n  []\\n- **Last result preview**:\\n  []\\n\\n=========================\\n# New User Request\\n=========================\\n\\nPlease fulfill the following request based on the above context:\\n\\ncan you show me the result of the join of all tables?\\n']\n- **Tools used so far**:\n  ['execute_query', 'get_table_schema', 'list_tables']\n- **Last SQL queries (if any)**:\n  []\n- **Last result preview**:\n  ['id | user_id | title | content | created_at | id | username | email | created_at\\n--------------------------------------------------------------------------------\\n1 | 1 | Hello World | This is my first post! | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107\\n2 | 2 | Bob\u2019s Thoughts | Here are some thoughts... | 2025-04-09 11:16:04.846107 | 2 | bob | bob@example.com | 2025-04-09 11:16:04.846107\\n3 | 1 | Follow-up Post | Another one from Alice. | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107']\n\n=========================\n# New User Request\n=========================\n\nPlease fulfill the following request based on the above context:\n\nhow many columns are there in this joined table?\n"}, {"type": "ai_function_call", "ai_said": ["Okay, I will determine the number of columns in the joined table. Since I have already performed a join operation and have the result in memory, I will use the `execute_query` tool to find the number of columns.\n\nHere's the SQL query I will use:", "```sql\nSELECT COUNT(*) FROM (SELECT p.id, p.user_id, p.title, p.content, p.created_at, u.id, u.username, u.email, u.created_at FROM posts p JOIN users u ON p.user_id = u.id) AS joined_table\n```", "\n\nNow, I will execute this query using the `execute_query` tool."], "tool": "execute_query", "args": "{\"query\": \"SELECT COUNT(*) FROM (SELECT p.id, p.user_id, p.title, p.content, p.created_at, u.id, u.username, u.email, u.created_at FROM posts p JOIN users u ON p.user_id = u.id) AS joined_table\"}"}, {"type": "tool_response", "tool": "execute_query", "response": "count\n-----\n3"}, {"type": "ai_final_answer", "ai_said": "The previous query joined the `posts` and `users` tables. The query to determine the number of columns in the joined table is: `SELECT COUNT(*) FROM (SELECT p.id, p.user_id, p.title, p.content, p.created_at, u.id, u.username, u.email, u.created_at FROM posts p JOIN users u ON p.user_id = u.id) AS joined_table`. The result shows that there are 9 columns."}]], "tools_used": ["list_tables", "get_table_schema", "execute_query", "execute_query"], "all_queries": [], "query_results": ["id | user_id | title | content | created_at | id | username | email | created_at\n--------------------------------------------------------------------------------\n1 | 1 | Hello World | This is my first post! | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107\n2 | 2 | Bob\u2019s Thoughts | Here are some thoughts... | 2025-04-09 11:16:04.846107 | 2 | bob | bob@example.com | 2025-04-09 11:16:04.846107\n3 | 1 | Follow-up Post | Another one from Alice. | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107", "count\n-----\n3"], "user_messages": ["=========================\n# Your Role\n=========================\n\nYou are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:\n\n- List available tables\n- Retrieve schema details\n- Execute SQL queries\n\nEach tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.\n\n=========================\n# Your Objective\n=========================\n\nWhen a user submits a request, you must:\n\n1. **Analyze the request** to determine the required data or action.\n2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).\n3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.\n4. **Execute the SQL query** and return the results.\n5. **Chain tools logically**, such as: List Tables \u2192 Get Schema \u2192 Write and Run Query.\n6. **Explain your reasoning and each step taken** to ensure clarity and transparency.\n\n=========================\n# Critical Rules\n=========================\n\n- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).\n- Always display any SQL query you generate along with the result of its execution.\n- Validate SQL syntax before execution to ensure correctness and safety.\n- Never make assumptions about the database structure \u2014 always use tools to confirm table and column names.\n- Be cautious, deliberate, and transparent in your actions.\n\n=========================\n# Short-Term Memory\n=========================\n\nYou have access to the following memory from this conversation. Use it if applicable for the current request.\n\n### Conversation Context:\n- **Previous user requests**:\n  []\n- **Tools used so far**:\n  []\n- **Last SQL queries (if any)**:\n  []\n- **Last result preview**:\n  []\n\n=========================\n# New User Request\n=========================\n\nPlease fulfill the following request based on the above context:\n\ncan you show me the result of the join of all tables?\n", "=========================\n# Your Role\n=========================\n\nYou are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:\n\n- List available tables\n- Retrieve schema details\n- Execute SQL queries\n\nEach tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.\n\n=========================\n# Your Objective\n=========================\n\nWhen a user submits a request, you must:\n\n1. **Analyze the request** to determine the required data or action.\n2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).\n3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.\n4. **Execute the SQL query** and return the results.\n5. **Chain tools logically**, such as: List Tables \u2192 Get Schema \u2192 Write and Run Query.\n6. **Explain your reasoning and each step taken** to ensure clarity and transparency.\n\n=========================\n# Critical Rules\n=========================\n\n- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).\n- Always display any SQL query you generate along with the result of its execution.\n- Validate SQL syntax before execution to ensure correctness and safety.\n- Never make assumptions about the database structure \u2014 always use tools to confirm table and column names.\n- Be cautious, deliberate, and transparent in your actions.\n\n=========================\n# Short-Term Memory\n=========================\n\nYou have access to the following memory from this conversation. Use it if applicable for the current request.\n\n### Conversation Context:\n- **Previous user requests**:\n  ['=========================\\n# Your Role\\n=========================\\n\\nYou are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:\\n\\n- List available tables\\n- Retrieve schema details\\n- Execute SQL queries\\n\\nEach tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.\\n\\n=========================\\n# Your Objective\\n=========================\\n\\nWhen a user submits a request, you must:\\n\\n1. **Analyze the request** to determine the required data or action.\\n2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).\\n3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.\\n4. **Execute the SQL query** and return the results.\\n5. **Chain tools logically**, such as: List Tables \u2192 Get Schema \u2192 Write and Run Query.\\n6. **Explain your reasoning and each step taken** to ensure clarity and transparency.\\n\\n=========================\\n# Critical Rules\\n=========================\\n\\n- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).\\n- Always display any SQL query you generate along with the result of its execution.\\n- Validate SQL syntax before execution to ensure correctness and safety.\\n- Never make assumptions about the database structure \u2014 always use tools to confirm table and column names.\\n- Be cautious, deliberate, and transparent in your actions.\\n\\n=========================\\n# Short-Term Memory\\n=========================\\n\\nYou have access to the following memory from this conversation. Use it if applicable for the current request.\\n\\n### Conversation Context:\\n- **Previous user requests**:\\n  []\\n- **Tools used so far**:\\n  []\\n- **Last SQL queries (if any)**:\\n  []\\n- **Last result preview**:\\n  []\\n\\n=========================\\n# New User Request\\n=========================\\n\\nPlease fulfill the following request based on the above context:\\n\\ncan you show me the result of the join of all tables?\\n']\n- **Tools used so far**:\n  ['execute_query', 'get_table_schema', 'list_tables']\n- **Last SQL queries (if any)**:\n  []\n- **Last result preview**:\n  ['id | user_id | title | content | created_at | id | username | email | created_at\\n--------------------------------------------------------------------------------\\n1 | 1 | Hello World | This is my first post! | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107\\n2 | 2 | Bob\u2019s Thoughts | Here are some thoughts... | 2025-04-09 11:16:04.846107 | 2 | bob | bob@example.com | 2025-04-09 11:16:04.846107\\n3 | 1 | Follow-up Post | Another one from Alice. | 2025-04-09 11:16:04.846107 | 1 | alice | alice@example.com | 2025-04-09 11:16:04.846107']\n\n=========================\n# New User Request\n=========================\n\nPlease fulfill the following request based on the above context:\n\nhow many columns are there in this joined table?\n"]}

postgre_mcp_client.py

@@ -5,8 +5,7 @@ from mcp.client.stdio import stdio_client
 from langchain_mcp_adapters.tools import load_mcp_tools
 from langgraph.prebuilt import create_react_agent
 from langchain.chat_models import init_chat_model
-from pprint import pprint
-import logging
+from conversation_memory import ConversationMemory
 
 llm = init_chat_model(model="gemini-2.0-flash-lite", model_provider="google_genai",api_key ="AIzaSyAuxYmci0DVU5l5L_YcxLlxHzR5MLn70js")
 
@@ -21,34 +20,7 @@ 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.
 """
-prompt_temp = """You are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools enable you to list tables, retrieve schema information, and execute SQL queries. You do not have access to prior memory — if you need any information (like table or column names), you must retrieve it using the appropriate tools. Tool descriptions also contain summaries of the tables, which you can use to understand the structure and content of the database.
-
-Your task is to carefully analyze the user's request and:
-
-Select the appropriate FastMCP tool(s) to gather any required database information.
-
-If you need to generate a SQL query to answer the request, always show the full query explicitly. 
-
-If you generate a valid SQL query, you have to execute it.
-
-Use only SELECT queries. Never use destructive operations (DELETE, DROP, UPDATE, etc.).
-
-Chain tools as needed (e.g., list tables → get schema → write and run query).
-
-Clearly explain your reasoning and each step taken to fulfill the user’s intent accurately and safely.
-
-Important Rules:
-
-Always show any SQL query you generate with the result of execution of the query.
-
-Double-check that the SQL syntax is valid and safe before running it.
-
-Never assume the database structure — retrieve it using tools when unsure.
-
-Be cautious, deliberate, and transparent in your actions.
-
-Here is the user request:
-can you show me the result of the join of all tables?"""
+prompt_temp = ""
 
 def parse_mcp_output(output_dict):
     result = []
@@ -83,10 +55,18 @@ def parse_mcp_output(output_dict):
 
                     result.append({
                         "type": "ai_function_call",
-                        "query": arguments_dict["query"]
+                        "ai_said": content,
+                        "tool": tool_name,
+                        "args": arguments
                     })
                 else:
                     print(f"ai said:{content}")
+                    result.append({
+                        "type": "ai_function_call",
+                        "ai_said": content,
+                        "tool": tool_name,
+                        "args": arguments
+                    })
 
             else:
                 print(f"ai final answer:{content}")
@@ -105,32 +85,70 @@ def parse_mcp_output(output_dict):
                 "response": content
             })
 
+        elif role_name == "HumanMessage":
+            result.append({
+                "type": "user_message",
+                "content": content
+            })
 
-    return result
 
+    return result
 
 
 
+request = "can you show me the result of the join of all tables?"
+request2 = "how many columns are there in this joined table?"
 async def main():
     async with stdio_client(server_params) as (read, write):
         async with ClientSession(read, write) as session:
             # Initialize the connection
             await session.initialize()
 
+            memory = ConversationMemory()
+            prompt = ""
+            with open(r"C:\Users\yukcus\Desktop\MCPTest\prompt_temp.txt", 'r', encoding='utf-8') as file:
+                prompt_temp = file.read()
+
+            prompt += prompt_temp
+
             # Get tools
             tools = await load_mcp_tools(session)
             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()
+
+            prompt = prompt.format(
+                user_requests=past_requests,
+                past_tools=past_tools,
+                last_queries=past_queries,
+                last_results=past_results,
+                new_request = request2
+            )
+
+
+
             # Create and run the agent
             agent = create_react_agent(llm, tools)
-            agent_response = await agent.ainvoke({"messages": prompt_temp})
+            agent_response = await agent.ainvoke({"messages": prompt})
 
 
             parsed_steps = parse_mcp_output(agent_response)
-            #pprint(parsed_steps)
 
 
+            memory.update_from_parsed(parsed_steps)
+
+            if request.strip().lower() == "stop":
+                memory.reset()
+                print("Conversation memory reset.")
+
+            else:
+                memory.save_memory()
+            #pprint(parsed_steps)
 
 
 

postgre_mcp_server.py

@@ -221,6 +221,7 @@ def get_foreign_keys(table_name: str) -> str:
     """
     return execute_query(sql)
 
+
 @mcp.tool(description="Fetches and formats the schema details for all tables in the configured database schema.")
 async def get_all_schemas() -> str:
     """Get schema information for all tables in the database"""
@@ -273,17 +274,17 @@ async def generate_select_query(table_name: str) -> list[PromptMessage]:
 
                     Table Schema:
                     {columns_text}
-                    
+
                     PostgreSQL SQL Best Practices:
                     - Use explicit column names instead of * when possible
                     - Include LIMIT clauses to restrict result sets
                     - Consider adding WHERE clauses to filter results
                     - Use appropriate indexing considerations
                     - Format SQL with proper indentation and line breaks
-                    
+
                     Create a basic SELECT query following these best practices:"""
-                                    )
-                                ]
+                )
+            ]
     except Exception as e:
         return [PromptMessage(f"Error generating select query: {str(e)}")]
 
@@ -313,25 +314,23 @@ async def generate_analytical_query(table_name: str) -> list[PromptMessage]:
 
                     Table Schema:
                     {columns_text}
-                    
+
                     PostgreSQL SQL Best Practices:
                     - Use aggregation functions (COUNT, SUM, AVG, MIN, MAX) appropriately
                     - Group data using GROUP BY for meaningful aggregations
                     - Filter groups with HAVING clauses when needed
                     - Consider using window functions for advanced analytics
                     - Format SQL with proper indentation and line breaks
-                    
+
                     Create a set of analytical queries for this table:"""
-                                    )
-                                ]
+                )
+            ]
     except Exception as e:
         return [PromptMessage(f"Error generating analytical query: {str(e)}")]
 
 
-
-
-
-@mcp.tool(description="Identifies both explicit and implied foreign key relationships for a given table using schema analysis and naming patterns.")
+@mcp.tool(
+    description="Identifies both explicit and implied foreign key relationships for a given table using schema analysis and naming patterns.")
 def find_relationships(table_name: str, schema: str = 'public') -> str:
     """Find both explicit and implied relationships for a table.
 

prompt_temp.txt

@@ -0,0 +1,58 @@
+=========================
+# Your Role
+=========================
+
+You are an expert in generating SQL queries and interacting with a PostgreSQL database using FastMCP tools. These tools allow you to:
+
+- List available tables
+- Retrieve schema details
+- Execute SQL queries
+
+Each tool may also provide summaries of table contents to help you understand the data structure. You have access to **short-term memory**, which stores relevant information from earlier steps or previous queries. If the memory is not empty, you **must** use it when processing the current request. Avoid repeating the same tool with identical input unless the result is **not already present in memory**.
+
+=========================
+# Your Objective
+=========================
+
+When a user submits a request, you must:
+
+1. **Analyze the request** to determine the required data or action.
+2. **Use FastMCP tools** to gather any necessary information (e.g., list tables or retrieve schema).
+3. **Generate a valid SQL SELECT query**, if needed, and clearly show the full query.
+4. **Execute the SQL query** and return the results.
+5. **Chain tools logically**, such as: List Tables → Get Schema → Write and Run Query.
+6. **Explain your reasoning and each step taken** to ensure clarity and transparency.
+
+=========================
+# Critical Rules
+=========================
+
+- Only use **SELECT** queries. Never use destructive operations (e.g., DELETE, DROP, UPDATE).
+- Always display any SQL query you generate along with the result of its execution.
+- Validate SQL syntax before execution to ensure correctness and safety.
+- Never make assumptions about the database structure — always use tools to confirm table and column names.
+- Be cautious, deliberate, and transparent in your actions.
+
+=========================
+# Short-Term Memory
+=========================
+
+You have access to the following memory from this conversation. Use it if applicable for the current request.
+
+### Conversation Context:
+- **Previous user requests**:
+  {user_requests}
+- **Tools used so far**:
+  {past_tools}
+- **Last SQL queries (if any)**:
+  {last_queries}
+- **Last result preview**:
+  {last_results}
+
+=========================
+# New User Request
+=========================
+
+Please fulfill the following request based on the above context:
+
+{new_request}