Update app.py

app.py

@@ -2,6 +2,8 @@ import gradio as gr
 from huggingface_hub import InferenceClient
 import json
 import asyncio
+import subprocess
+import os
 from typing import Optional, Dict, Any, List
 
 
@@ -12,6 +14,7 @@ class MCPContextManager:
         self.context = []
         self.tools = {}
         self.resources = {}
+        self.mcp_servers = {}
         
     def add_context(self, role: str, content: str, metadata: Optional[Dict] = None):
         """Add context entry following MCP specification"""
@@ -42,6 +45,10 @@ class MCPContextManager:
             "content": content
         }
     
+    def register_mcp_server(self, server_name: str, config: Dict):
+        """Register an MCP server configuration"""
+        self.mcp_servers[server_name] = config
+    
     def get_context_window(self, max_tokens: int = 4096) -> List[Dict]:
         """Get context window within token limits"""
         return self.context[-10:]  # Simple implementation
@@ -70,15 +77,40 @@ class MCPContextManager:
         return json.dumps({
             "context": self.context,
             "tools": self.get_available_tools(),
-            "resources": list(self.resources.keys())
+            "resources": list(self.resources.keys()),
+            "mcp_servers": list(self.mcp_servers.keys())
         }, indent=2)
 
 
 # Initialize MCP Manager
 mcp_manager = MCPContextManager()
 
+# Register MCP Servers (from your config)
+mcp_manager.register_mcp_server("postgres-full", {
+    "command": "npx",
+    "args": [
+        "-y",
+        "mcp-postgres-full-access",
+        "postgresql://neondb_owner:npg_oGg8yphr6FeZ@ep-summer-art-a1jpcb05-pooler.ap-southeast-1.aws.neon.tech/neondb?sslmode=require&channel_binding=require"
+    ],
+    "env": {
+        "TRANSACTION_TIMEOUT_MS": "60000",
+        "MAX_CONCURRENT_TRANSACTIONS": "5",
+        "PG_STATEMENT_TIMEOUT_MS": "30000"
+    }
+})
+
+mcp_manager.register_mcp_server("filesystem", {
+    "command": "npx",
+    "args": [
+        "-y",
+        "@modelcontextprotocol/server-filesystem",
+        "C:\\Users\\CHAN\\Documents\\PROJECTS"
+    ]
+})
+
 
-# Register example MCP tools
+# MCP Tool Handlers
 async def calculator_handler(args):
     """Calculator tool handler"""
     operation = args.get("operation")
@@ -120,7 +152,97 @@ async def web_search_handler(args):
     return f"Search results for: {query} (MCP tool simulation)"
 
 
-# Register tools with MCP manager
+async def git_command_handler(args):
+    """Git command execution handler"""
+    command = args.get("command", "")
+    repo_path = args.get("repo_path", os.getcwd())
+    
+    try:
+        # Security: Only allow specific safe git commands
+        allowed_commands = ["status", "log", "branch", "diff", "commit", "push", "pull", "add"]
+        cmd_parts = command.split()
+        
+        if not cmd_parts or cmd_parts[0] not in allowed_commands:
+            return {"error": "Command not allowed or invalid"}
+        
+        # Execute git command
+        result = subprocess.run(
+            ["git"] + cmd_parts,
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "returncode": result.returncode,
+            "success": result.returncode == 0
+        }
+    except subprocess.TimeoutExpired:
+        return {"error": "Command timed out"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def postgres_query_handler(args):
+    """PostgreSQL query handler (simulated - would connect to your Neon DB)"""
+    query = args.get("query", "")
+    operation = args.get("operation", "SELECT")
+    
+    # Note: In production, this would actually connect to your Neon PostgreSQL
+    # using the connection string from mcp_servers
+    return {
+        "message": f"Would execute {operation} query: {query}",
+        "note": "Connect to: postgresql://neondb_owner@ep-summer-art-a1jpcb05-pooler.ap-southeast-1.aws.neon.tech/neondb",
+        "status": "simulated"
+    }
+
+
+async def filesystem_handler(args):
+    """Filesystem operations handler"""
+    operation = args.get("operation")  # read, write, list, search
+    path = args.get("path", "")
+    content = args.get("content", "")
+    
+    base_path = r"C:\Users\CHAN\Documents\PROJECTS"
+    full_path = os.path.join(base_path, path)
+    
+    try:
+        if operation == "read":
+            if os.path.exists(full_path):
+                with open(full_path, 'r', encoding='utf-8') as f:
+                    return {"content": f.read(), "success": True}
+            return {"error": "File not found", "success": False}
+        
+        elif operation == "list":
+            if os.path.exists(full_path):
+                items = os.listdir(full_path)
+                return {"items": items, "success": True}
+            return {"error": "Directory not found", "success": False}
+        
+        elif operation == "write":
+            with open(full_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            return {"message": "File written successfully", "success": True}
+        
+        elif operation == "search":
+            pattern = args.get("pattern", "")
+            results = []
+            for root, dirs, files in os.walk(full_path if os.path.isdir(full_path) else base_path):
+                for file in files:
+                    if pattern.lower() in file.lower():
+                        results.append(os.path.join(root, file))
+            return {"results": results, "count": len(results), "success": True}
+        
+        return {"error": "Invalid operation", "success": False}
+    
+    except Exception as e:
+        return {"error": str(e), "success": False}
+
+
+# Register all tools with MCP manager
 mcp_manager.register_tool(
     name="calculator",
     description="Perform basic arithmetic operations",
@@ -164,6 +286,50 @@ mcp_manager.register_tool(
     handler=web_search_handler
 )
 
+mcp_manager.register_tool(
+    name="git",
+    description="Execute git commands (status, log, commit, push, pull, add, branch, diff)",
+    parameters={
+        "type": "object",
+        "properties": {
+            "command": {"type": "string", "description": "Git command (e.g., 'status', 'commit -am \"message\"', 'push')"},
+            "repo_path": {"type": "string", "description": "Repository path (optional)"}
+        },
+        "required": ["command"]
+    },
+    handler=git_command_handler
+)
+
+mcp_manager.register_tool(
+    name="postgres",
+    description="Execute PostgreSQL queries on Neon database",
+    parameters={
+        "type": "object",
+        "properties": {
+            "query": {"type": "string"},
+            "operation": {"type": "string", "enum": ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "ALTER"]}
+        },
+        "required": ["query"]
+    },
+    handler=postgres_query_handler
+)
+
+mcp_manager.register_tool(
+    name="filesystem",
+    description="Perform filesystem operations (read, write, list, search)",
+    parameters={
+        "type": "object",
+        "properties": {
+            "operation": {"type": "string", "enum": ["read", "write", "list", "search"]},
+            "path": {"type": "string"},
+            "content": {"type": "string"},
+            "pattern": {"type": "string"}
+        },
+        "required": ["operation", "path"]
+    },
+    handler=filesystem_handler
+)
+
 
 def respond(
     message,
@@ -220,7 +386,7 @@ def respond(
 def call_mcp_tool(tool_name: str, arguments_json: str):
     """Interface for calling MCP tools from UI"""
     try:
-        arguments = json.loads(arguments_json)
+        arguments = json.loads(arguments_json) if arguments_json else {}
         result = asyncio.run(mcp_manager.call_tool(tool_name, arguments))
         return json.dumps({"success": True, "result": result}, indent=2)
     except Exception as e:
@@ -238,6 +404,11 @@ def get_mcp_tools_list():
     return json.dumps(tools, indent=2)
 
 
+def get_mcp_servers():
+    """Get configured MCP servers"""
+    return json.dumps(mcp_manager.mcp_servers, indent=2)
+
+
 """
 Enhanced Gradio interface with Model Context Protocol (MCP) support
 """
@@ -246,7 +417,7 @@ chatbot = gr.ChatInterface(
     type="messages",
     additional_inputs=[
         gr.Textbox(
-            value="You are a friendly AI assistant with access to Model Context Protocol (MCP) tools. You can use tools like calculator, memory storage, and web search to help users.",
+            value="You are a powerful AI assistant with MCP tools including: Git operations, PostgreSQL database access (Neon), filesystem operations, calculator, memory, and web search.",
             label="System message",
             lines=3
         ),
@@ -263,9 +434,9 @@ chatbot = gr.ChatInterface(
     ],
 )
 
-with gr.Blocks(title="AI Chat with MCP Support") as demo:
-    gr.Markdown("# 🤖 AI Chatbot with Model Context Protocol (MCP)")
-    gr.Markdown("Enhanced with MCP for context management, tool usage, and resource handling")
+with gr.Blocks(title="AI Chat with Full MCP Support") as demo:
+    gr.Markdown("# 🤖 AI Chatbot with Full Model Context Protocol (MCP)")
+    gr.Markdown("✨ Connected to PostgreSQL (Neon), Filesystem, Git, and more!")
     
     with gr.Tabs():
         with gr.Tab("💬 Chat"):
@@ -275,23 +446,47 @@ with gr.Blocks(title="AI Chat with MCP Support") as demo:
         
         with gr.Tab("🛠️ MCP Tools"):
             gr.Markdown("### Available MCP Tools")
-            tools_display = gr.JSON(label="Registered Tools")
-            refresh_tools_btn = gr.Button("Refresh Tools List")
+            tools_display = gr.Code(language="json", label="Registered Tools")
+            refresh_tools_btn = gr.Button("🔄 Refresh Tools List")
+            
+            gr.Markdown("### 🎯 Quick Actions")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**Git Commands**")
+                    git_cmd = gr.Textbox(label="Git Command", placeholder="status")
+                    git_btn = gr.Button("Execute Git")
+                    
+                with gr.Column():
+                    gr.Markdown("**Filesystem**")
+                    fs_operation = gr.Dropdown(["list", "read", "search"], label="Operation")
+                    fs_path = gr.Textbox(label="Path", placeholder="PROJECTS")
+                    fs_btn = gr.Button("Execute FS")
             
-            gr.Markdown("### Call MCP Tool")
+            gr.Markdown("### 🔧 Custom Tool Call")
             with gr.Row():
                 tool_name_input = gr.Textbox(label="Tool Name", placeholder="calculator")
-                tool_args_input = gr.Textbox(
+                tool_args_input = gr.Code(
                     label="Arguments (JSON)",
-                    placeholder='{"operation": "add", "a": 5, "b": 3}',
-                    lines=3
+                    value='{"operation": "add", "a": 5, "b": 3}',
+                    language="json",
+                    lines=5
                 )
-            call_tool_btn = gr.Button("Call Tool")
-            tool_result = gr.JSON(label="Tool Result")
+            call_tool_btn = gr.Button("▶️ Call Tool")
+            tool_result = gr.Code(language="json", label="Tool Result", lines=10)
+            
+            # Event handlers
+            refresh_tools_btn.click(fn=get_mcp_tools_list, outputs=tools_display)
             
-            refresh_tools_btn.click(
-                fn=get_mcp_tools_list,
-                outputs=tools_display
+            git_btn.click(
+                fn=lambda cmd: call_mcp_tool("git", json.dumps({"command": cmd})),
+                inputs=[git_cmd],
+                outputs=tool_result
+            )
+            
+            fs_btn.click(
+                fn=lambda op, path: call_mcp_tool("filesystem", json.dumps({"operation": op, "path": path})),
+                inputs=[fs_operation, fs_path],
+                outputs=tool_result
             )
             
             call_tool_btn.click(
@@ -300,42 +495,79 @@ with gr.Blocks(title="AI Chat with MCP Support") as demo:
                 outputs=tool_result
             )
         
+        with gr.Tab("🌐 MCP Servers"):
+            gr.Markdown("### Configured MCP Servers")
+            servers_display = gr.Code(language="json", label="MCP Server Configuration")
+            refresh_servers_btn = gr.Button("🔄 Refresh Servers")
+            
+            refresh_servers_btn.click(fn=get_mcp_servers, outputs=servers_display)
+            
+            gr.Markdown("""
+            #### Connected Servers:
+            - **postgres-full**: Neon PostgreSQL Database
+            - **filesystem**: Local file system access (C:\\Users\\CHAN\\Documents\\PROJECTS)
+            """)
+        
         with gr.Tab("📋 MCP Context"):
             gr.Markdown("### Export MCP Context")
             gr.Markdown("View and export the current context window managed by MCP")
-            export_btn = gr.Button("Export Context")
-            context_display = gr.Code(language="json", label="MCP Context")
+            export_btn = gr.Button("📥 Export Context")
+            context_display = gr.Code(language="json", label="MCP Context", lines=15)
             
-            export_btn.click(
-                fn=export_mcp_context,
-                outputs=context_display
-            )
+            export_btn.click(fn=export_mcp_context, outputs=context_display)
         
         with gr.Tab("ℹ️ About MCP"):
             gr.Markdown("""
             ### Model Context Protocol (MCP)
             
-            MCP is a protocol for managing context, tools, and resources in AI applications.
+            This AI assistant is powered by MCP with full access to:
+            
+            #### 🗄️ Database Access
+            - **PostgreSQL (Neon)**: Full database operations
+            - Connection: `ep-summer-art-a1jpcb05-pooler.ap-southeast-1.aws.neon.tech`
+            
+            #### 📁 Filesystem Access
+            - **Root**: `C:\\Users\\CHAN\\Documents\\PROJECTS`
+            - Operations: read, write, list, search
             
-            **Features:**
-            - 🔧 **Tool Integration**: Register and call tools dynamically
-            - 💾 **Context Management**: Maintain conversation history and context
-            - 📦 **Resource Handling**: Store and retrieve resources (files, data, etc.)
-            - 🔌 **Extensible**: Easy to add new tools and capabilities
+            #### 🔧 Available Tools:
+            1. **Git**: Execute git commands (status, commit, push, pull, etc.)
+            2. **PostgreSQL**: Query and manage your Neon database
+            3. **Filesystem**: Read/write files, list directories, search
+            4. **Calculator**: Perform arithmetic operations
+            5. **Memory**: Store and retrieve session data
+            6. **Web Search**: Search for information
             
-            **Available Tools:**
-            1. **Calculator**: Perform arithmetic operations
-            2. **Memory**: Store and retrieve information
-            3. **Web Search**: Search for information (simulated)
+            #### 📖 Example Commands:
             
-            **Example Tool Call:**
+            **Git:**
             ```json
             {
-              "tool": "calculator",
+              "tool": "git",
               "arguments": {
-                "operation": "add",
-                "a": 10,
-                "b": 5
+                "command": "status"
+              }
+            }
+            ```
+            
+            **Filesystem:**
+            ```json
+            {
+              "tool": "filesystem",
+              "arguments": {
+                "operation": "list",
+                "path": "PROJECTS"
+              }
+            }
+            ```
+            
+            **PostgreSQL:**
+            ```json
+            {
+              "tool": "postgres",
+              "arguments": {
+                "query": "SELECT * FROM users LIMIT 10",
+                "operation": "SELECT"
               }
             }
             ```
@@ -344,3 +576,4 @@ with gr.Blocks(title="AI Chat with MCP Support") as demo:
 
 if __name__ == "__main__":
     demo.launch()
+