Chart mcp start

.gitignore

@@ -1,2 +1,22 @@
+=======
 config/api_key.yml
-config/config.yml
+config.yml
+
+# Ignore practice file
+practice_formatting_server.py
+
+# Ignore pycache files
+pycache/__pycache__/
+*.py[cod]
+
+# Ignore virtual environment folders
+venv/
+env/
+.virtualenv/
+
+# Ignore IDE specific files
+.vscode/
+
+# Ignore test output files
+*.html
+*.pdf

config/config.txt → config/mcpservers.yml

@@ -1,22 +1,16 @@
-# FinRLExtention Configuration
-
-# Gemini API Configuration
-gemini:
-  # API key for Google Gemini - replace with your actual key
-  api_key: ""  # Set your API key here or use environment variable
-
-  # Model to use use this as default
-  model: "gemini-2.5-flash"
-
-  # Temperature for response generation (0.0 - 1.0)
-  temperature: 0.7
-
-  # Maximum tokens in the response
-  max_output_tokens: 8192
-
 # MCP Server Configurations
 # Add your MCP servers here
+
 mcp_servers:
+  - name: "research"
+    command: "python"
+    args: ["src/backend/mcp_servers/mcp_research/server.py"]
+
+  # THIS IS THE FORMATTING SERVER (COMMENTED BECAUSE OF ERRORS THAT WILL NEED TO BE FIXED)
+  # - name: "formatting"
+  #   command: "python"
+  #   args: ["src/backend/mcp_servers/mcp_formatting/server.py"]
+
   # Example server configuration:
   # - name: "example-server"
   #   command: "python"

requirements.txt

@@ -5,9 +5,13 @@ google-generativeai>=0.8.0
 
 # MCP (Model Context Protocol) SDK
 mcp>=1.0.0
+fastmcp
 
 # Configuration
 pyyaml>=6.0
 
+# OpenAI SDK (used for Perplexity API compatibility)
+openai>=1.0.0
+
 # Async support
 anyio>=4.0.0

src/backend/charts/temp_file.txt

@@ -0,0 +1 @@
+This is a temporary file.

src/backend/mcp_client.py

@@ -9,6 +9,7 @@
 import asyncio
 import json
 import logging
+from contextlib import AsyncExitStack
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Optional
@@ -49,28 +50,35 @@ class MCPClient:
     and uses Gemini to process user requests while handling tool calls.
     """
 
-    def __init__(self, config_path: Optional[str] = None):
+    def __init__(self, config_path: Optional[str] = None, mcp_servers_path: Optional[str] = None):
         """
         Initialize the MCP Client.
 
         Args:
             config_path: Path to the config.yml file. If None, uses default location.
+            mcp_servers_path: Path to the mcpservers.yml file. If None, uses default location.
         """
         self.config_path = Path(config_path) if config_path else self._get_default_config_path()
+        self.mcp_servers_path = Path(mcp_servers_path) if mcp_servers_path else self._get_default_mcp_servers_path()
         self.config: dict[str, Any] = {}
         self.gemini_config: Optional[GeminiConfig] = None
         self.server_configs: list[MCPServerConfig] = []
         self.sessions: dict[str, ClientSession] = {}
         self.tools: dict[str, dict[str, Any]] = {}
         self.tool_to_server: dict[str, str] = {}
         self._model: Optional[genai.GenerativeModel] = None
+        self._exit_stack = AsyncExitStack()
 
     def _get_default_config_path(self) -> Path:
         """Get the default config path relative to this file."""
         return Path(__file__).parent.parent.parent / "config" / "config.yml"
 
+    def _get_default_mcp_servers_path(self) -> Path:
+        """Get the default MCP servers config path relative to this file."""
+        return Path(__file__).parent.parent.parent / "config" / "mcpservers.yml"
+
     def load_config(self) -> None:
-        """Load configuration from the YAML config file."""
+        """Load configuration from the YAML config files."""
         if not self.config_path.exists():
             raise FileNotFoundError(f"Config file not found: {self.config_path}")
 
@@ -90,7 +98,19 @@ def load_config(self) -> None:
             max_output_tokens=gemini_cfg.get("max_output_tokens", 8192),
         )
 
-        servers_cfg = self.config.get("mcp_servers", [])
+        self._load_mcp_servers_config()
+
+    def _load_mcp_servers_config(self) -> None:
+        """Load MCP servers configuration from the mcpservers.yml file."""
+        if not self.mcp_servers_path.exists():
+            logger.warning(f"MCP servers config file not found: {self.mcp_servers_path}")
+            self.server_configs = []
+            return
+
+        with open(self.mcp_servers_path, "r") as f:
+            mcp_config = yaml.safe_load(f) or {}
+
+        servers_cfg = mcp_config.get("mcp_servers", [])
         if servers_cfg is not None:
             self.server_configs = [
                 MCPServerConfig(
@@ -135,11 +155,13 @@ async def connect_to_server(self, server_config: MCPServerConfig) -> ClientSessi
             env=server_config.env if server_config.env else None,
         )
 
-        stdio_transport = await stdio_client(server_params).__aenter__()
-        read_stream, write_stream = stdio_transport
+        read_stream, write_stream = await self._exit_stack.enter_async_context(
+            stdio_client(server_params)
+        )
 
-        session = ClientSession(read_stream, write_stream)
-        await session.__aenter__()
+        session = await self._exit_stack.enter_async_context(
+            ClientSession(read_stream, write_stream)
+        )
         await session.initialize()
 
         self.sessions[server_config.name] = session
@@ -378,29 +400,27 @@ def _convert_history_to_gemini(
 
     async def close(self) -> None:
         """Close all server connections."""
-        for server_name, session in self.sessions.items():
-            try:
-                await session.__aexit__(None, None, None)
-                logger.info(f"Closed connection to {server_name}")
-            except Exception as e:
-                logger.error(f"Error closing connection to {server_name}: {e}")
-
+        await self._exit_stack.aclose()
         self.sessions.clear()
         self.tools.clear()
         self.tool_to_server.clear()
 
 
-async def create_mcp_client(config_path: Optional[str] = None) -> MCPClient:
+async def create_mcp_client(
+    config_path: Optional[str] = None,
+    mcp_servers_path: Optional[str] = None,
+) -> MCPClient:
     """
     Create and initialize an MCP client.
 
     Args:
         config_path: Optional path to config file.
+        mcp_servers_path: Optional path to MCP servers config file.
 
     Returns:
         Initialized MCPClient instance.
     """
-    client = MCPClient(config_path)
+    client = MCPClient(config_path, mcp_servers_path)
     client.load_config()
     await client.connect_all_servers()
     await client.discover_tools()

src/backend/mcp_servers/mcp_chart_generation/.python-version

@@ -0,0 +1 @@
+3.14

src/backend/mcp_servers/mcp_chart_generation/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from chart-mcp-server!")
+
+
+if __name__ == "__main__":
+    main()

src/backend/mcp_servers/mcp_chart_generation/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "chart-mcp-server"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "fastmcp>=2.14.5",
+    "google-generativeai>=0.8.6",
+    "matplotlib>=3.10.8",
+]