fix: memory store issue again, update prompts

conversation_memory.py

@@ -13,11 +13,14 @@ class ConversationMemory:
         for step in parsed_steps:
             if step['type'] == 'ai_function_call':
                 tools.append(step['tool'])
-                if 'query' in step:
-                    self.all_queries.append(step['query'])
+                if 'query' in step['args']:
+                    args_dict = json.loads(step['args'])
+                    query = args_dict['query']
+                    self.all_queries.append(query)
             elif step['type'] == 'ai_final_answer':
-                if 'query' in step['ai_said'][0]:
-                    self.all_queries.append(step['ai_said'][1])
+                if step['ai_said']:
+                    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'])

postgre_mcp_client.py

@@ -24,7 +24,8 @@ 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 postes and users tables?"
+#request = "can you show me the result of the join of posts and users tables?"
+#request = "But you did not execute the query. Can you tell me why?"
 #request = "May ı see the table?"
 #request = "stop"
 #request = "how many columns are there in this joined table?"

postgre_mcp_server.py

@@ -63,7 +63,7 @@ async def base_prompt_query() -> str:
                     # Your Role
                     ==========================
 
-                    You are an expert in generating SQL queries and interacting with a PostgreSQL database using **FastMCP tools**. These tools allow you to:
+                    You are an expert in generating and executing SQL queries and interacting with a PostgreSQL database using **FastMCP tools**. These tools allow you to:
 
                     - List available tables
                     - Retrieve schema details
@@ -87,7 +87,7 @@ 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**.
+                    4. Execute the query and **return the execution result of the query**.
                     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. 
@@ -104,7 +104,7 @@ 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.
+                    - If you generate a SQL query, immediately call the **execute_query** tool using that query. Do not delay or wait for user confirmation.
 
 
                     ---
@@ -132,80 +132,6 @@ async def base_prompt_query() -> str:
 
                     ---
 
-                    ==========================
-                    # Tool Usage Examples
-                    ==========================
-
-                    ### Example 1 — Unknown Table Name:
-                    **User Request:** "Get the total sales for each product."
-                    **Steps:**
-                    1. List Tables → Identify a table like `sales_data`.
-                    2. Get Schema for `sales_data` → Confirm columns like `product_name`, `total_sales`.
-                    3. Generate and execute query:
-                       ```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."
-
-                    **Steps:**
-                    1. Use memory to check if we already retrieved schema.
-                    2. If not, List Tables → Identify a table like `customers`.
-                    3. Get Schema for `customers` → Confirm column `email`.
-                    4. Query:
-                       ```sql
-                       SELECT email FROM customers;
-
-
-                    ### Example 3 — Memory Usage:
-                    **User Request:** "Get top 5 most expensive products."
-
-                    **Steps:**
-                    1. Check memory for schema of `products` table.
-                    2. If column `price` exists in memory, directly generate:
-                       ```sql
-                       SELECT * FROM products ORDER BY price DESC LIMIT 5;
-
-
-                    ### Example 4 — COUNT Query:
-                    **User Request:** "How many orders have been placed?"
-
-                    **Steps:**
-                    1. List Tables → Identify a table like `orders`.
-                    2. Get Schema for `orders` → Confirm it's the right table.
-                    3. Query:
-                       ```sql
-                       SELECT COUNT(*) FROM orders;
-
-
-                    ### Example 5 — WHERE Clause (Filtering):
-                    **User Request:** "Get the names of customers from Germany."
-
-                    **Steps:**
-                    1. Use memory or List Tables → Identify `customers` table.
-                    2. Get Schema for `customers` → Confirm columns like `country`, `name`.
-                    3. Generate and execute query:
-                       ```sql
-                       SELECT name FROM customers WHERE country = 'Germany';
-
-
-                    ## Example 6 — Basic Aggregation**
-                    **User Request:** "Get total sales for each product"
-
-                    **Steps:**
-                    1.  Use memory or List Tables → Get schema for `sales_data`
-                    2. Generate and execute query:
-                    ```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."
@@ -218,6 +144,12 @@ async def base_prompt_query() -> str:
                       > SELECT * FROM customers WHERE country = 'Germany';
                       > ```
 
+
+                    **Reminder:** 
+                    **Every time you generate a SQL query, call **execute_query** right after and include the result in your final response.**
+                    **If you do not execute the generated SQL query, this will be the violation of the instructions**
+                    **Your final answer cannot be only a SQL query, you will have to call **execute_query** and give the result of the call with the SQL query.** 
+                    ---
                     =========================
                     # New User Request
                     =========================
@@ -299,6 +231,181 @@ Use this memory to resolve any references in the user's latest request.
 
 ---
 
+==========================
+# Reference Conversion Rules for PostgreSQL to ANSI SQL
+==========================
+## Use the following rules as examples and guidance. You are not limited to these rules — apply your own knowledge of SQL standards and PostgreSQL to perform accurate conversions, even in cases not explicitly covered below.
+
+### 1. String Concatenation
+- **PostgreSQL:** || for string concatenation
+- **ANSI SQL:** CONCAT() function
+
+**Example:**
+```sql
+-- PostgreSQL
+SELECT first_name || ' ' || last_name AS full_name FROM users;
+
+-- ANSI SQL
+SELECT CONCAT(first_name, ' ', last_name) AS full_name FROM users;
+
+### 2. LIMIT Clause
+
+- **PostgreSQL:** Uses `LIMIT`  
+- **ANSI SQL:** Uses `FETCH FIRST n ROWS ONLY`
+
+**Example:**
+```sql
+-- PostgreSQL
+SELECT * FROM posts LIMIT 10;
+
+-- ANSI SQL
+SELECT * FROM posts FETCH FIRST 10 ROWS ONLY;
+
+### 3. ILIKE (Case-insensitive LIKE)
+
+- **PostgreSQL:** `ILIKE`  
+- **ANSI SQL:** Use `LOWER(column) LIKE` or `UPPER(column) LIKE`
+
+**Example:**
+```sql
+-- PostgreSQL
+SELECT * FROM users WHERE username ILIKE 'john%';
+
+-- ANSI SQL
+SELECT * FROM users WHERE LOWER(username) LIKE 'john%';
+
+### 4. Type Casting
+
+- **PostgreSQL:** `'123'::INTEGER`  
+- **ANSI SQL:** `CAST('123' AS INTEGER)`
+
+**Example:**
+```sql
+-- PostgreSQL
+SELECT '123'::INTEGER;
+
+-- ANSI SQL
+SELECT CAST('123' AS INTEGER);
+
+### 5. INSERT ... RETURNING
+
+- **PostgreSQL:** Supports `RETURNING` to get values immediately  
+- **ANSI SQL:** No equivalent; use a separate `SELECT` query
+
+**Example:**
+```sql
+-- PostgreSQL
+INSERT INTO users (username) VALUES ('john') RETURNING id;
+
+-- ANSI SQL
+-- No direct equivalent; you must SELECT after INSERT
+INSERT INTO users (username) VALUES ('john');
+SELECT id FROM users WHERE username = 'john';
+
+
+### 6. UPSERT (INSERT ON CONFLICT)
+
+- **PostgreSQL:** `INSERT ... ON CONFLICT`  
+- **ANSI SQL:** Use `MERGE` (available in ANSI SQL-2003+)
+
+**Example:**
+```sql
+-- PostgreSQL
+INSERT INTO users (id, username)
+VALUES (1, 'john')
+ON CONFLICT (id)
+DO UPDATE SET username = EXCLUDED.username;
+
+-- ANSI SQL
+MERGE INTO users AS target
+USING (SELECT 1 AS id, 'john' AS username) AS source
+ON (target.id = source.id)
+WHEN MATCHED THEN
+  UPDATE SET username = source.username
+WHEN NOT MATCHED THEN
+  INSERT (id, username) VALUES (source.id, source.username);
+
+### 7. SERIAL (Auto-increment IDs)
+
+- **PostgreSQL:** `SERIAL` keyword  
+- **ANSI SQL:** Use `IDENTITY` in table creation
+
+**Example:**
+```sql
+-- PostgreSQL
+CREATE TABLE users (
+  id SERIAL PRIMARY KEY,
+  username TEXT
+);
+
+-- ANSI SQL
+CREATE TABLE users (
+  id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  username VARCHAR(255)
+);
+
+
+### 8. Arrays and Accessing Arrays
+
+- **PostgreSQL:** Supports arrays and uses `[index]`  
+- **ANSI SQL:** No array type; use normalized relational design
+
+**Example:**
+```sql
+-- PostgreSQL
+SELECT tags[1] FROM posts;
+
+-- ANSI SQL
+-- No equivalent. Use a separate `post_tags` table instead.
+
+### 9. PostgreSQL Extensions and Functions
+
+- Replace PostgreSQL-specific functions like `NOW()`, `CURRENT_DATE`, etc., with ANSI SQL equivalents when available.
+
+**Example:**
+```sql
+-- PostgreSQL
+SELECT NOW(), CURRENT_DATE;
+
+-- ANSI SQL
+SELECT CURRENT_TIMESTAMP, CURRENT_DATE;
+
+### 10. Table Aliases with 'AS'
+
+- **PostgreSQL:** `FROM users AS u`  
+- **ANSI SQL:** `FROM users u` (without `AS` is also valid)
+
+**Note:** Both are valid ANSI SQL — no change needed.
+
+### 11. Boolean Type
+
+- **PostgreSQL:** Uses `BOOLEAN`, and accepts `TRUE` / `FALSE`  
+- **ANSI SQL:** Also supports `BOOLEAN`, but in some systems may need conversion to `CHAR(1)` with `'Y'` / `'N'`
+
+**Example (if needed):**
+```sql
+-- PostgreSQL
+SELECT * FROM flags WHERE is_enabled = TRUE;
+
+-- ANSI SQL (fallback style)
+SELECT * FROM flags WHERE is_enabled = 'Y';
+
+
+### 12. Text vs. VARCHAR
+
+- **PostgreSQL:** Allows unbounded `TEXT`  
+- **ANSI SQL:** Use `VARCHAR(n)`
+
+**Example:**
+```sql
+-- PostgreSQL
+CREATE TABLE posts (content TEXT);
+
+-- ANSI SQL
+CREATE TABLE posts (content VARCHAR(65535));
+
+---
+
 ==========================
 # Examples
 ==========================