fast-agent-mcp 0.0.11__tar.gz → 0.0.12__tar.gz

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.0.11
+Version: 0.0.12
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -217,6 +217,7 @@ Requires-Dist: numpy>=2.2.1
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
+Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyyaml>=6.0.2
@@ -271,6 +272,7 @@ Other bootstrap examples include a Researcher (with Evaluator-Optimizer workflow
 ### llmindset.co.uk fork:
 
 - "FastAgent" style prototyping, with per-agent models
+- Api keys through Environment Variables
 - Warm-up / Post-Workflow Agent Interactions
 - Quick Setup
 - Interactive Prompt Mode

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/README.md

@@ -35,6 +35,7 @@ Other bootstrap examples include a Researcher (with Evaluator-Optimizer workflow
 ### llmindset.co.uk fork:
 
 - "FastAgent" style prototyping, with per-agent models
+- Api keys through Environment Variables
 - Warm-up / Post-Workflow Agent Interactions
 - Quick Setup
 - Interactive Prompt Mode

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.0.11"
+version = "0.0.12"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -29,6 +29,7 @@ dependencies = [
     "scikit-learn>=1.6.0",
     "anthropic>=0.42.0",
     "openai>=1.63.2",
+    "prompt-toolkit>=3.0.50",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/src/mcp_agent/cli/commands/bootstrap.py

@@ -33,11 +33,7 @@ EXAMPLE_TYPES = {
         "description": "Research agent example with additional evaluation/optimization\n"
         "example. Uses Brave Search and Docker MCP Servers.\n"
         "Creates examples in a 'researcher' subdirectory.",
-        "files": [
-            "researcher.py",
-            "researcher-eval.py",
-            "mcp_agent.secrets.yaml.example",
-        ],
+        "files": ["researcher.py", "researcher-eval.py", "fastagent.config.yaml"],
         "create_subdir": True,
     },
     "data-analysis": {

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/src/mcp_agent/cli/main.py

@@ -40,11 +40,11 @@ def show_welcome():
 
     console.print("\n[bold]Getting Started:[/bold]")
     console.print("1. Set up a new project:")
-    console.print("   mcp-agent setup")
+    console.print("   fastagent setup")
     console.print("\n2. Try an example:")
-    console.print("   mcp-agent bootstrap create decorator")
+    console.print("   fastagent bootstrap create decorator")
     console.print("\nUse --help with any command for more information")
-    console.print("Example: mcp-agent bootstrap --help")
+    console.print("Example: fastagent bootstrap --help")
 
 
 @app.callback(invoke_without_command=True)
@@ -56,7 +56,7 @@ def main(
         True, "--color/--no-color", help="Enable/disable color output"
     ),
 ):
-    """MCP Agent CLI - Build effective agents using Model Context Protocol (MCP).
+    """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
 
     Use --help with any command for detailed usage information.
     """

fast_agent_mcp-0.0.12/src/mcp_agent/core/enhanced_prompt.py

@@ -0,0 +1,315 @@
+"""
+Enhanced prompt functionality with advanced prompt_toolkit features.
+"""
+
+from typing import List
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.lexers import PygmentsLexer
+from prompt_toolkit.filters import Condition
+from pygments.lexers.python import PythonLexer
+from rich import print as rich_print
+
+# Map of agent names to their history
+agent_histories = {}
+
+# Store available agents for auto-completion
+available_agents = set()
+
+# Keep track of multi-line mode state
+in_multiline_mode = False
+
+# Track which agents have already shown welcome messages
+agent_messages_shown = set()
+
+
+class AgentCompleter(Completer):
+    """Provide completion for agent names and common commands."""
+
+    def __init__(self, agents: List[str], commands: List[str] = None, agent_types: dict = None):
+        self.agents = agents
+        self.commands = commands or ["help", "clear", "STOP"]
+        self.agent_types = agent_types or {}
+
+    def get_completions(self, document, complete_event):
+        """Synchronous completions method - this is what prompt_toolkit expects by default"""
+        text = document.text_before_cursor.lower()
+
+        # Complete commands
+        if text.startswith("/"):
+            cmd = text[1:]
+            for command in self.commands:
+                if command.lower().startswith(cmd):
+                    yield Completion(
+                        command,
+                        start_position=-len(cmd),
+                        display=command,
+                        display_meta="Command",
+                    )
+
+        # Complete agent names for agent-related commands
+        elif text.startswith("@"):
+            agent_name = text[1:]
+            for agent in self.agents:
+                if agent.lower().startswith(agent_name.lower()):
+                    # Get agent type or default to "Agent"
+                    agent_type = self.agent_types.get(agent, "Agent")
+                    yield Completion(
+                        agent,
+                        start_position=-len(agent_name),
+                        display=agent,
+                        display_meta=agent_type,
+                    )
+
+
+def create_keybindings(on_toggle_multiline=None, app=None):
+    """Create custom key bindings."""
+    kb = KeyBindings()
+
+    @kb.add("c-m", filter=Condition(lambda: not in_multiline_mode))
+    def _(event):
+        """Enter: accept input when not in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-m", filter=Condition(lambda: in_multiline_mode))
+    def _(event):
+        """Enter: insert newline when in multiline mode."""
+        event.current_buffer.insert_text("\n")
+
+    @kb.add("escape", "enter")
+    def _(event):
+        """Alt+Enter: always submit even in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-t")
+    def _(event):
+        """Ctrl+T: Toggle multiline mode."""
+        global in_multiline_mode
+        in_multiline_mode = not in_multiline_mode
+
+        # Force redraw the app to update toolbar
+        if event.app:
+            event.app.invalidate()
+        elif app:
+            app.invalidate()
+
+        # Call the toggle callback if provided
+        if on_toggle_multiline:
+            on_toggle_multiline(in_multiline_mode)
+
+        # Instead of printing, we'll just update the toolbar
+        # The toolbar will show the current mode
+
+    @kb.add("c-l")
+    def _(event):
+        """Ctrl+L: Clear input."""
+        event.current_buffer.text = ""
+
+    return kb
+
+
+async def get_enhanced_input(
+    agent_name: str,
+    default: str = "",
+    show_default: bool = False,
+    show_stop_hint: bool = False,
+    multiline: bool = False,
+    available_agent_names: List[str] = None,
+    syntax: str = None,
+    agent_types: dict = None,
+) -> str:
+    """
+    Enhanced input with advanced prompt_toolkit features.
+
+    Args:
+        agent_name: Name of the agent (used for prompt and history)
+        default: Default value if user presses enter
+        show_default: Whether to show the default value in the prompt
+        show_stop_hint: Whether to show the STOP hint
+        multiline: Start in multiline mode
+        available_agent_names: List of agent names for auto-completion
+        syntax: Syntax highlighting (e.g., 'python', 'sql')
+        agent_types: Dictionary mapping agent names to their types for display
+
+    Returns:
+        User input string
+    """
+    global in_multiline_mode, available_agents
+
+    # Update global state
+    in_multiline_mode = multiline
+    if available_agent_names:
+        available_agents = set(available_agent_names)
+
+    # Get or create history object for this agent
+    if agent_name not in agent_histories:
+        agent_histories[agent_name] = InMemoryHistory()
+
+    # Define callback for multiline toggle
+    def on_multiline_toggle(enabled):
+        nonlocal session
+        if hasattr(session, "app") and session.app:
+            session.app.invalidate()
+
+    # Define toolbar function that will update dynamically
+    def get_toolbar():
+        if in_multiline_mode:
+            mode_style = "ansired"  # More noticeable for multiline mode
+            mode_text = "MULTILINE"
+            toggle_text = "Normal Editing"
+        else:
+            mode_style = "ansigreen"
+            mode_text = "NORMAL"
+            toggle_text = "Multiline Editing"
+
+        shortcuts = [
+            ("Ctrl+T", toggle_text),
+            ("Alt+Enter", "Submit" if in_multiline_mode else ""),
+            ("Ctrl+L", "Clear"),
+            ("↑/↓", "History"),
+        ]
+        # Only show relevant shortcuts based on mode
+        shortcuts = [(k, v) for k, v in shortcuts if v]
+
+        shortcut_text = " | ".join(f"{key}:{action}" for key, action in shortcuts)
+        return HTML(
+            f" <b>Agent:</b> <ansiblue> {agent_name} </ansiblue> | <b>Mode:</b> <{mode_style}> {mode_text} </{mode_style}> | {shortcut_text}"
+        )
+
+    # Create session with history and completions
+    session = PromptSession(
+        history=agent_histories[agent_name],
+        completer=AgentCompleter(
+            agents=list(available_agents) if available_agents else [],
+            agent_types=agent_types or {},
+        ),
+        complete_while_typing=True,
+        lexer=PygmentsLexer(PythonLexer) if syntax == "python" else None,
+        multiline=Condition(lambda: in_multiline_mode),
+        complete_in_thread=True,
+        mouse_support=True,
+        bottom_toolbar=get_toolbar,  # Pass the function here
+    )
+
+    # Create key bindings with a reference to the app
+    bindings = create_keybindings(
+        on_toggle_multiline=on_multiline_toggle, app=session.app
+    )
+    session.app.key_bindings = bindings
+
+    # Create formatted prompt text
+    prompt_text = f"<ansicyan>{agent_name}</ansicyan> > "
+
+    # Add default value display if requested
+    if show_default and default and default != "STOP":
+        prompt_text = f"{prompt_text} [<ansigreen>{default}</ansigreen>] "
+
+    # Only show hints at startup if requested
+    if show_stop_hint:
+        if default == "STOP":
+            rich_print("[yellow]Press <ENTER> to finish.[/yellow]")
+        else:
+            rich_print("Enter a prompt, or [red]STOP[/red] to finish")
+            if default:
+                rich_print(
+                    f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
+                )
+
+    # Mention available features but only on first usage for this agent
+    if agent_name not in agent_messages_shown:
+        rich_print(
+            "[dim]Tip: Type /help for commands, press F1 for keyboard shortcuts. Ctrl+T toggles multiline mode. @Agent to switch agent[/dim]"
+        )
+        agent_messages_shown.add(agent_name)
+
+    # Process special commands
+    def pre_process_input(text):
+        # Command processing
+        if text and text.startswith("/"):
+            cmd = text[1:].strip().lower()
+            if cmd == "help":
+                return "HELP"
+            elif cmd == "clear":
+                return "CLEAR"
+            elif cmd == "agents":
+                return "LIST_AGENTS"
+
+        # Agent switching
+        if text and text.startswith("@"):
+            return f"SWITCH:{text[1:].strip()}"
+
+        return text
+
+    # Get the input - using async version
+    try:
+        result = await session.prompt_async(HTML(prompt_text), default=default)
+        return pre_process_input(result)
+    except KeyboardInterrupt:
+        # Handle Ctrl+C gracefully
+        return "STOP"
+    except EOFError:
+        # Handle Ctrl+D gracefully
+        return "STOP"
+    except Exception as e:
+        # Log and gracefully handle other exceptions
+        print(f"\nInput error: {type(e).__name__}: {e}")
+        return "STOP"
+
+
+async def handle_special_commands(command, agent_app=None):
+    """Handle special input commands."""
+    # Quick guard for empty or None commands
+    if not command:
+        return False
+
+    # Check for special commands
+    if command == "HELP":
+        rich_print("\n[bold]Available Commands:[/bold]")
+        rich_print("  /help          - Show this help")
+        rich_print("  /clear         - Clear screen")
+        rich_print("  /agents        - List available agents")
+        rich_print("  @agent_name    - Switch to agent")
+        rich_print("  STOP           - End session")
+        rich_print("\n[bold]Keyboard Shortcuts:[/bold]")
+        rich_print(
+            "  Enter          - Submit (normal mode) / New line (multiline mode)"
+        )
+        rich_print("  Alt+Enter      - Always submit (even in multiline mode)")
+        rich_print("  Ctrl+T         - Toggle multiline mode")
+        rich_print("  Ctrl+L         - Clear input")
+        rich_print("  Up/Down        - Navigate history")
+        rich_print("  F1             - Show help")
+        return True
+
+    elif command == "CLEAR":
+        # Clear screen (ANSI escape sequence)
+        print("\033c", end="")
+        return True
+
+    elif command == "LIST_AGENTS":
+        if available_agents:
+            rich_print("\n[bold]Available Agents:[/bold]")
+            for agent in sorted(available_agents):
+                rich_print(f"  @{agent}")
+        else:
+            rich_print("[yellow]No agents available[/yellow]")
+        return True
+
+    elif isinstance(command, str) and command.startswith("SWITCH:"):
+        agent_name = command.split(":", 1)[1]
+        if agent_name in available_agents:
+            if agent_app:
+                rich_print(f"[green]Switching to agent: {agent_name}[/green]")
+                return {"switch_agent": agent_name}
+            else:
+                rich_print(
+                    "[yellow]Agent switching not available in this context[/yellow]"
+                )
+        else:
+            rich_print(f"[red]Unknown agent: {agent_name}[/red]")
+        return True
+
+    return False

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/src/mcp_agent/core/fastagent.py

@@ -28,7 +28,6 @@ from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
 )
 from mcp_agent.workflows.router.router_llm import LLMRouter
 from mcp_agent.config import Settings
-from rich.prompt import Prompt
 from rich import print
 from mcp_agent.progress_display import progress_display
 from mcp_agent.workflows.llm.model_factory import ModelFactory
@@ -161,34 +160,73 @@ class AgentApp:
 
     async def prompt(self, agent_name: Optional[str] = None, default: str = "") -> str:
         """
-        Interactive prompt for sending messages.
+        Interactive prompt for sending messages with advanced features.
 
         Args:
             agent_name: Optional target agent name (uses default if not specified)
-            default_prompt: Default message to use when user presses enter
+            default: Default message to use when user presses enter
         """
+        from .enhanced_prompt import get_enhanced_input, handle_special_commands
 
         agent = agent_name or self._default
 
         if agent not in self._agents:
             raise ValueError(f"No agent named '{agent}'")
+
+        # Pass all available agent names for auto-completion
+        available_agents = list(self._agents.keys())
+        
+        # Create agent_types dictionary mapping agent names to their types
+        agent_types = {}
+        for name, proxy in self._agents.items():
+            # Determine agent type based on the proxy type
+            if isinstance(proxy, LLMAgentProxy):
+                # Convert AgentType.BASIC.value ("agent") to "Agent"
+                agent_types[name] = "Agent"
+            elif isinstance(proxy, RouterProxy):
+                agent_types[name] = "Router"
+            elif isinstance(proxy, WorkflowProxy):
+                # For workflow proxies, check the workflow type
+                workflow = proxy._workflow
+                if isinstance(workflow, Orchestrator):
+                    agent_types[name] = "Orchestrator"
+                elif isinstance(workflow, ParallelLLM):
+                    agent_types[name] = "Parallel"
+                elif isinstance(workflow, EvaluatorOptimizerLLM):
+                    agent_types[name] = "Evaluator"
+                else:
+                    agent_types[name] = "Workflow"
+
         result = ""
         while True:
             with progress_display.paused():
-                if default == "STOP":
-                    print("Press <ENTER> to finish.")
-                elif default != "":
-                    print("Enter a prompt, or [red]STOP[/red] to finish.")
-                    print(
-                        f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
-                    )
-                else:
-                    print("Enter a prompt, or [red]STOP[/red] to finish")
-
-                prompt_text = f"[blue]{agent}[/blue] >"
-                user_input = Prompt.ask(
-                    prompt=prompt_text, default=default, show_default=False
+                # Use the enhanced input method with advanced features
+                user_input = await get_enhanced_input(
+                    agent_name=agent,
+                    default=default,
+                    show_default=(default != ""),
+                    show_stop_hint=True,
+                    multiline=False,  # Default to single-line mode
+                    available_agent_names=available_agents,
+                    syntax=None,  # Can enable syntax highlighting for code input
+                    agent_types=agent_types,  # Pass agent types for display
                 )
+
+                # Handle special commands
+                command_result = await handle_special_commands(user_input, self)
+
+                # Check if we should switch agents
+                if (
+                    isinstance(command_result, dict)
+                    and "switch_agent" in command_result
+                ):
+                    agent = command_result["switch_agent"]
+                    continue
+
+                # Skip further processing if command was handled
+                if command_result:
+                    continue
+
                 if user_input.upper() == "STOP":
                     return
                 if user_input == "":
@@ -400,12 +438,12 @@ class FastAgent(ContextDependent):
             elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
                 # Check both evaluator and optimizer exist
                 evaluator = agent_data["evaluator"]
-                optimizer = agent_data["optimizer"]
+                generator = agent_data["generator"]
                 missing = []
                 if evaluator not in available_components:
                     missing.append(f"evaluator: {evaluator}")
-                if optimizer not in available_components:
-                    missing.append(f"optimizer: {optimizer}")
+                if generator not in available_components:
+                    missing.append(f"generator: {generator}")
                 if missing:
                     raise AgentConfigError(
                         f"Evaluator-Optimizer '{name}' references non-existent components: {', '.join(missing)}"
@@ -672,7 +710,7 @@ class FastAgent(ContextDependent):
     def evaluator_optimizer(
         self,
         name: str,
-        optimizer: str,
+        generator: str,
         evaluator: str,
         min_rating: str = "GOOD",
         max_refinements: int = 3,
@@ -684,7 +722,7 @@ class FastAgent(ContextDependent):
 
         Args:
             name: Name of the workflow
-            optimizer: Name of the optimizer agent
+            generator: Name of the generator agent
             evaluator: Name of the evaluator agent
             min_rating: Minimum acceptable quality rating (EXCELLENT, GOOD, FAIR, POOR)
             max_refinements: Maximum number of refinement iterations
@@ -699,7 +737,7 @@ class FastAgent(ContextDependent):
             wrapper_needed=True,
         )(
             name=name,
-            optimizer=optimizer,
+            generator=generator,
             evaluator=evaluator,
             min_rating=min_rating,
             max_refinements=max_refinements,
@@ -853,27 +891,27 @@ class FastAgent(ContextDependent):
 
                 elif agent_type == AgentType.EVALUATOR_OPTIMIZER:
                     # Get the referenced agents - unwrap from proxies
-                    optimizer = self._unwrap_proxy(
-                        active_agents[agent_data["optimizer"]]
+                    generator = self._unwrap_proxy(
+                        active_agents[agent_data["generator"]]
                     )
                     evaluator = self._unwrap_proxy(
                         active_agents[agent_data["evaluator"]]
                     )
 
-                    if not optimizer or not evaluator:
+                    if not generator or not evaluator:
                         raise ValueError(
                             f"Missing agents for workflow {name}: "
-                            f"optimizer={agent_data['optimizer']}, "
+                            f"generator={agent_data['generator']}, "
                             f"evaluator={agent_data['evaluator']}"
                         )
 
                     # TODO: Remove legacy - factory usage is only needed for str evaluators
                     # Later this should only be passed when evaluator is a string
                     optimizer_model = (
-                        optimizer.config.model if isinstance(optimizer, Agent) else None
+                        generator.config.model if isinstance(generator, Agent) else None
                     )
                     instance = EvaluatorOptimizerLLM(
-                        optimizer=optimizer,
+                        generator=generator,
                         evaluator=evaluator,
                         min_rating=QualityRating[agent_data["min_rating"]],
                         max_refinements=agent_data["max_refinements"],

fast_agent_mcp-0.0.12/src/mcp_agent/resources/examples/internal/agent.py

@@ -0,0 +1,17 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("FastAgent Example")
+
+
+# Define the agent
+@fast.agent(servers=["fetch"])
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/src/mcp_agent/resources/examples/internal/job.py

@@ -52,7 +52,7 @@ fast = FastAgent("PMO Job Description Generator")
 )
 @fast.evaluator_optimizer(
     name="job_description_writer",
-    optimizer="content_generator",
+    generator="content_generator",
     evaluator="consistency_checker",
     min_rating="EXCELLENT",
     max_refinements=2,

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.12}/src/mcp_agent/resources/examples/mcp_researcher/researcher-eval.py

@@ -35,7 +35,7 @@ Summarize your evaluation as a structured response with:
 - Specific feedback and areas for improvement.""",
 )
 @agents.evaluator_optimizer(
-    optimizer="Researcher",
+    generator="Researcher",
     evaluator="Evaluator",
     max_refinements=5,
     min_rating="EXCELLENT",

fast_agent_mcp-0.0.12/src/mcp_agent/resources/examples/researcher/fastagent.config.yaml

@@ -0,0 +1,53 @@
+#
+# Please edit this configuration file to match your environment (on Windows).
+# Examples in comments below - check/change the paths.
+#
+#
+
+execution_engine: asyncio
+logger:
+  type: file
+  level: error
+  truncate_tools: true
+
+mcp:
+  servers:
+    brave:
+      # On windows replace the command and args line to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-brave-search` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-brave-search"]
+      env:
+        # You can also place your BRAVE_API_KEY in the fastagent.secrets.yaml file.
+        BRAVE_API_KEY: <your_brave_api_key>
+    filesystem:
+      # On windows update the command and arguments to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","./agent_folder"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "./agent_folder/"]
+    interpreter:
+      command: "docker"
+      args: [
+          "run",
+          "-i",
+          "--rm",
+          "--pull=always",
+          "-v",
+          "./agent_folder:/mnt/data/",
+          # Docker needs the absolute path on Windows (e.g. "x:/fastagent/agent_folder:/mnt/data/")
+          # "./agent_folder:/mnt/data/",
+          "ghcr.io/evalstate/mcp-py-repl:latest",
+        ]
+      roots:
+        - uri: "file://./agent_folder/"
+          name: "agent_folder"
+          server_uri_alias: "file:///mnt/data/"
+    fetch:
+      command: "uvx"
+      args: ["mcp-server-fetch"]