ci:add version

app.py

@@ -13,7 +13,7 @@ import logging
 
 # Load environment variables
 load_dotenv()
-
+VERSION = "0.0.1"
 
 # ======================================= Load DB configs
 def load_db_configs():
@@ -120,6 +120,8 @@ with gr.Blocks(css=custom_css, theme=xtheme) as demo:
                 """
                 <h1 style='text-align: center; margin-bottom: 1rem'>Talk to Your Data</h1>
                 <p style='text-align: center'>Ask questions about your database, analyze and visualize data.</p>
+                <p style='text-align: center; color: #666; font-size: 0.9em; margin-top: -0.5rem'>Version: {}</p>
+                """.format(VERSION)
                 """
             )
     with gr.Row(elem_classes="container"):
@@ -130,7 +132,8 @@ with gr.Blocks(css=custom_css, theme=xtheme) as demo:
                     height=1000,
                     show_label=False,
                     elem_classes="chat-container",
-                    render_markdown=True
+                    render_markdown=True,
+                    type="messages"
                 ),
                 textbox=gr.Textbox(
                     placeholder="Type your questions here...",
@@ -163,7 +166,7 @@ with gr.Blocks(css=custom_css, theme=xtheme) as demo:
                 - 👥 Total number of customers
                 - 📈 Top 10 customers by ticket count
                 - 📋 Ticket count by status and visualize
-                - 📆 Average ticket reopen count per month
+                - 📆 Average ticket reopened
                 - 🧹 Clear memory : `/clear-cache`
                 """)
 

postgre_mcp_server.py

@@ -41,7 +41,7 @@ class DbContext:
 async def db_lifespan(server: FastMCP) -> AsyncIterator[DbContext]:
     """Manage database connection lifecycle"""
     dsn = os.environ["DB_URL"]
-    schema = os.environ["DB_SCHEMA"]
+    db_schema = os.environ["DB_SCHEMA"]
 
     pool = await asyncpg.create_pool(
         dsn,
@@ -52,7 +52,7 @@ async def db_lifespan(server: FastMCP) -> AsyncIterator[DbContext]:
         command_timeout=300,
     )
     try:
-        yield DbContext(pool=pool, schema=schema)
+        yield DbContext(pool=pool, schema=db_schema)
     finally:
         # Clean up
         await pool.close()
@@ -248,9 +248,9 @@ async def execute_query(
 
 
 # Database helper functions
-async def get_all_tables(pool, schema):
+async def get_all_tables(pool, db_schema):
     """Get all tables from the database"""
-    print(f"schema: {schema}")
+    print(f"schema: {db_schema}")
     async with pool.acquire() as conn:
         result = await conn.fetch("""
             SELECT c.relname AS table_name
@@ -265,12 +265,12 @@ async def get_all_tables(pool, schema):
             AND n.nspname = $1
             AND c.relname NOT LIKE 'pg_%'
             ORDER BY c.relname;
-        """, schema)
+        """, db_schema)
 
         return result
 
 
-async def get_table_schema_info(pool, schema, table_name):
+async def get_table_schema_info(pool, db_schema, table_name):
     """Get schema information for a specific table"""
     async with pool.acquire() as conn:
         columns = await conn.fetch("""
@@ -284,7 +284,7 @@ async def get_table_schema_info(pool, schema, table_name):
             WHERE table_schema = $1
             AND table_name = $2
             ORDER BY ordinal_position;
-        """, schema, table_name)
+        """, db_schema, table_name)
 
         return columns
 
@@ -325,13 +325,13 @@ async def list_tables() -> str:
 async def get_table_schema(table_name: str) -> str:
     """Get schema information for a specific table"""
     try:
-        schema = os.environ["DB_SCHEMA"]
+        db_schema = os.environ["DB_SCHEMA"]
 
         async with db_lifespan(mcp) as db_ctx:
-            columns = await get_table_schema_info(db_ctx.pool, schema, table_name)
+            columns = await get_table_schema_info(db_ctx.pool, db_schema, table_name)
 
             if not columns:
-                return f"Table '{table_name}' not found in {schema} schema."
+                return f"Table '{table_name}' not found in {db_schema} schema."
 
             return format_table_schema(table_name, columns)
     except asyncpg.exceptions.PostgresError as e:
@@ -348,7 +348,7 @@ def get_foreign_keys(table_name: str) -> str:
         table_name: The name of the table to get foreign keys from
         schema: The schema name (defaults to 'public')
     """
-    schema = os.environ["DB_SCHEMA"]
+    db_schema = os.environ["DB_SCHEMA"]
 
     sql = """
     SELECT 
@@ -366,19 +366,19 @@ def get_foreign_keys(table_name: str) -> str:
     JOIN information_schema.constraint_column_usage ccu
         ON rc.unique_constraint_name = ccu.constraint_name
     WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_schema = {schema}
+        AND tc.table_schema = {db_schema}
         AND tc.table_name = {table_name}
     ORDER BY tc.constraint_name, kcu.ordinal_position
     """
 
-    return execute_query(sql, (schema, table_name))
+    return execute_query(sql, (db_schema, table_name))
 
 
 @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"""
     try:
-        schema = os.environ["DB_SCHEMA"]
+        db_schema = os.environ["DB_SCHEMA"]
 
         async with db_lifespan(mcp) as db_ctx:
             tables = await get_all_tables(db_ctx.pool, db_ctx.schema)
@@ -389,7 +389,7 @@ async def get_all_schemas() -> str:
             all_schemas = []
             for table in tables:
                 table_name = table['table_name']
-                columns = await get_table_schema_info(db_ctx.pool, schema, table_name)
+                columns = await get_table_schema_info(db_ctx.pool, db_schema, table_name)
                 table_schema = format_table_schema(table_name, columns)
                 all_schemas.append(table_schema)
                 all_schemas.append("")  # Add empty line between tables
@@ -447,7 +447,7 @@ async def generate_analytical_query(table_name: str) -> list[PromptMessage]:
     Args:
         table_name: The name of the table to generate analytical queries for
     """ 
-    schema = os.environ["DB_SCHEMA"]
+    db_schema = os.environ["DB_SCHEMA"]
     try:
         async with db_lifespan(mcp) as db_ctx:
             pool = db_ctx.pool
@@ -455,7 +455,7 @@ async def generate_analytical_query(table_name: str) -> list[PromptMessage]:
                 columns = await conn.fetch(f"""
                     SELECT column_name, data_type
                     FROM information_schema.columns 
-                    WHERE table_schema = {schema} AND table_name = {table_name}
+                    WHERE table_schema = {db_schema} AND table_name = {table_name}
                     ORDER BY ordinal_position
                 """, db_ctx.schema, table_name)