fast-agent-mcp 0.0.7__py3-none-any.whl

mcp_agent/cli/commands/bootstrap.py

@@ -0,0 +1,221 @@
+"""Bootstrap command to create example applications."""
+
+import shutil
+from pathlib import Path
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+app = typer.Typer(
+    help="Create example applications and learn MCP Agent patterns",
+    no_args_is_help=True,
+)
+console = Console()
+
+EXAMPLE_TYPES = {
+    "decorator": {
+        "description": "Decorator pattern example showing different agent composition approaches",
+        "details": """
+        The decorator example shows how to:
+        - Compose agents using the decorator pattern
+        - Add capabilities like optimization and routing
+        - Run agents in parallel
+        - Handle complex agent interactions
+        """,
+        "files": [
+            "main.py",
+            "optimizer.py",
+            "orchestrator.py",
+            "parallel.py",
+            "router.py",
+            "tiny.py",
+        ],
+    },
+    "researcher": {
+        "description": "Research agent example with evaluation optimization",
+        "details": """
+        The researcher example demonstrates:
+        - Building a research-focused agent
+        - Implementing evaluation strategies
+        - Optimizing agent responses
+        - Handling complex research tasks
+        """,
+        "files": ["main.py", "main-evalopt.py"],
+    },
+}
+
+
+def copy_example_files(
+    example_type: str, target_dir: Path, force: bool = False
+) -> list[str]:
+    """Copy example files from resources to target directory."""
+    created = []
+
+    # During development, use the source directory
+    source_dir = (
+        Path(__file__).parent.parent.parent
+        / "resources"
+        / "examples"
+        / ("decorator" if example_type == "decorator" else "mcp_researcher")
+    )
+
+    if not source_dir.exists():
+        console.print(f"[red]Error: Source directory not found: {source_dir}[/red]")
+        return created
+
+    for filename in EXAMPLE_TYPES[example_type]["files"]:
+        source = source_dir / filename
+        target = target_dir / filename
+
+        try:
+            if not source.exists():
+                console.print(f"[red]Error: Source file not found: {source}[/red]")
+                continue
+
+            if target.exists() and not force:
+                console.print(f"[yellow]Skipping[/yellow] {filename} (already exists)")
+                continue
+
+            shutil.copy2(source, target)
+            created.append(filename)
+            console.print(f"[green]Created[/green] {filename}")
+
+        except Exception as e:
+            console.print(f"[red]Error copying {filename}: {str(e)}[/red]")
+
+    return created
+
+
+def show_examples_overview():
+    """Show an overview of available examples."""
+    console.print("\n[bold]MCP Agent Example Applications[/bold]")
+    console.print("Learn how to build effective agents through practical examples\n")
+
+    # Create a table for the examples
+    table = Table(title="Available Examples")
+    table.add_column("Example", style="green")
+    table.add_column("Description")
+    table.add_column("Files", style="blue")
+
+    for name, info in EXAMPLE_TYPES.items():
+        table.add_row(name, info["description"], "\n".join(info["files"]))
+
+    console.print(table)
+
+    # Show usage instructions
+    console.print("\n[bold]Usage:[/bold]")
+    console.print("1. Create a new example:")
+    console.print("   mcp-agent bootstrap create <example-name>")
+    console.print("\n2. Specify a directory:")
+    console.print(
+        "   mcp-agent bootstrap create <example-name> --directory ./my-project"
+    )
+    console.print("\n3. Force overwrite existing files:")
+    console.print("   mcp-agent bootstrap create <example-name> --force")
+
+    console.print("\n[bold]Examples:[/bold]")
+    console.print("   mcp-agent bootstrap create decorator")
+    console.print(
+        "   mcp-agent bootstrap create researcher --directory ./research-agent"
+    )
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """Bootstrap example applications to learn MCP Agent patterns.
+
+    Create working examples that demonstrate different agent patterns and capabilities.
+    Use these as starting points for your own agent applications.
+    """
+    if ctx.invoked_subcommand is None:
+        show_examples_overview()
+
+
+@app.command()
+def create(
+    example_type: str = typer.Argument(
+        None, help="Type of example to create (decorator or researcher)"
+    ),
+    directory: str = typer.Option(
+        ".", "--directory", "-d", help="Directory where example files will be created"
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force overwrite existing files"
+    ),
+):
+    """Create a new example application.
+
+    This will create a set of example files based on the chosen type:
+
+    \b
+    - decorator: Decorator pattern example showing different agent composition approaches
+    - researcher: Research agent example with evaluation optimization
+    """
+    if not example_type:
+        show_examples_overview()
+        return
+
+    example_type = example_type.lower()
+    if example_type not in EXAMPLE_TYPES:
+        console.print(f"[red]Error:[/red] Unknown example type '{example_type}'")
+        console.print("\nAvailable types:")
+        for name in EXAMPLE_TYPES:
+            console.print(f"  - {name}")
+        raise typer.Exit(1)
+
+    target_dir = Path(directory).resolve()
+    if not target_dir.exists():
+        target_dir.mkdir(parents=True)
+        console.print(f"Created directory: {target_dir}")
+
+    # Show example details
+    console.print(f"\n[bold]Creating {example_type} example[/bold]")
+    console.print(
+        Panel(
+            EXAMPLE_TYPES[example_type]["details"].strip(),
+            title="About this example",
+            expand=False,
+        )
+    )
+
+    if not force:
+        # Check for existing files first
+        existing = []
+        for f in EXAMPLE_TYPES[example_type]["files"]:
+            if (target_dir / f).exists():
+                existing.append(f)
+
+        if existing:
+            console.print(
+                "\n[yellow]Warning:[/yellow] The following files already exist:"
+            )
+            for f in existing:
+                console.print(f"  - {f}")
+            console.print("\nUse --force to overwrite existing files")
+            raise typer.Exit(1)
+
+    created = copy_example_files(example_type, target_dir, force)
+
+    if created:
+        console.print("\n[green]Setup completed successfully![/green]")
+        console.print("\nCreated files:")
+        for f in created:
+            console.print(f"  - {f}")
+
+        console.print("\n[bold]Next Steps:[/bold]")
+        if example_type == "decorator":
+            console.print("1. Review main.py for the basic example")
+            console.print("2. Check other files for different composition patterns:")
+            console.print("   - optimizer.py: Add optimization capabilities")
+            console.print("   - router.py: Route requests to different agents")
+            console.print("   - parallel.py: Run agents in parallel")
+            console.print("3. Run with: python main.py")
+        else:
+            console.print("1. Review main.py for the basic researcher example")
+            console.print(
+                "2. Try main-evalopt.py for the evaluation optimization version"
+            )
+            console.print("3. Run with: python main.py or python main-evalopt.py")
+    else:
+        console.print("\n[yellow]No files were created.[/yellow]")

mcp_agent/cli/commands/config.py

@@ -0,0 +1,11 @@
+import typer
+
+app = typer.Typer()
+
+
+@app.command()
+def show():
+    """Show the configuration."""
+    raise NotImplementedError(
+        "The show configuration command has not been implemented yet"
+    )

mcp_agent/cli/commands/setup.py

@@ -0,0 +1,229 @@
+from pathlib import Path
+import typer
+from rich.prompt import Confirm
+from rich.console import Console
+
+app = typer.Typer()
+console = Console()
+
+FASTAGENT_CONFIG_TEMPLATE = """
+# FastAgent Configuration File
+
+# Default Model Configuration:
+# 
+# Takes format:
+#   <provider>.<model_string>.<reasoning_effort?> (e.g. anthropic.claude-3-5-sonnet-20241022 or openai.o3-mini.low)
+# Accepts aliases for Anthropic Models: haiku, haiku3, sonnet, sonnet35, opus, opus3
+# and OpenAI Models: gpt-4o-mini, gpt-4o, o1, o1-mini, o3-mini
+#
+# If not specified, defaults to "haiku". 
+# Can be overriden with a command line switch --model=<model>, or within the Agent constructor.
+
+default_model: sonnet
+
+# Logging and Console Configuration:
+logging:
+    # level: "debug" | "info" | "warning" | "error"
+    # type: "none" | "console" | "file" | "http"
+    # path: "/path/to/logfile.jsonl"
+
+    
+    # Switch the progress display on or off
+    # progress_display: true
+
+    # Show chat User/Assistant messages on the console
+    # show_chat: true
+    # Show tool calls on the console
+    # show_tools: true
+    # Truncate long tool responses on the console 
+    # truncate_tools: true
+
+# MCP Servers
+mcp:
+    servers:
+        fetch:
+            command: "uvx"
+            args: ["mcp-server-fetch"]    
+
+"""
+
+FASTAGENT_SECRETS_TEMPLATE = """
+# FastAgent Secrets Configuration
+# WARNING: Keep this file secure and never commit to version control
+
+openai:
+    api_key: <your-api-key-here>
+anthropic:
+    api_key: <your-api-key-here>
+
+# Example of setting an MCP Server environment variable
+mcp:
+    servers:
+        brave:
+            env:
+                BRAVE_API_KEY: <your_api_key_here>
+
+"""
+
+GITIGNORE_TEMPLATE = """
+# FastAgent secrets file
+fastagent-secrets.yaml
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+.env
+.venv
+env/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+"""
+
+AGENT_EXAMPLE_TEMPLATE = """
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+agent_app = FastAgent("FastAgent Example")
+# Uncomment the below to disable human input callback tool
+# agent_app.app._human_input_callback = None
+
+
+# Define the agent
+@agent_app.agent(servers=["fetch"])
+# @agent_app.agent(servers=["fetch"])
+async def main():
+    # use the --model= command line switch to specify model
+    async with agent_app.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+"""
+
+
+def find_gitignore(path: Path) -> bool:
+    """Check if a .gitignore file exists in this directory or any parent."""
+    current = path
+    while current != current.parent:  # Stop at root directory
+        if (current / ".gitignore").exists():
+            return True
+        current = current.parent
+    return False
+
+
+def create_file(path: Path, content: str, force: bool = False) -> bool:
+    """Create a file with given content if it doesn't exist or force is True."""
+    if path.exists() and not force:
+        should_overwrite = Confirm.ask(
+            f"[yellow]Warning:[/yellow] {path} already exists. Overwrite?",
+            default=False,
+        )
+        if not should_overwrite:
+            console.print(f"Skipping {path}")
+            return False
+
+    path.write_text(content.strip() + "\n")
+    console.print(f"[green]Created[/green] {path}")
+    return True
+
+
+@app.callback(invoke_without_command=True)
+def init(
+    config_dir: str = typer.Option(
+        ".",
+        "--config-dir",
+        "-c",
+        help="Directory where configuration files will be created",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force overwrite existing files"
+    ),
+):
+    """Initialize a new FastAgent project with configuration files and example agent."""
+
+    config_path = Path(config_dir).resolve()
+    if not config_path.exists():
+        should_create = Confirm.ask(
+            f"Directory {config_path} does not exist. Create it?", default=True
+        )
+        if should_create:
+            config_path.mkdir(parents=True)
+        else:
+            raise typer.Abort()
+
+    # Check for existing .gitignore
+    needs_gitignore = not find_gitignore(config_path)
+
+    console.print("\n[bold]FastAgent Setup[/bold]\n")
+    console.print("This will create the following files:")
+    console.print(f"  - {config_path}/fastagent.config.yaml")
+    console.print(f"  - {config_path}/fastagent.secrets.yaml")
+    console.print(f"  - {config_path}/agent.py")
+    if needs_gitignore:
+        console.print(f"  - {config_path}/.gitignore")
+
+    if not Confirm.ask("\nContinue?", default=True):
+        raise typer.Abort()
+
+    # Create configuration files
+    created = []
+    if create_file(
+        config_path / "fastagent.config.yaml", FASTAGENT_CONFIG_TEMPLATE, force
+    ):
+        created.append("fastagent.yaml")
+
+    if create_file(
+        config_path / "fastagent.secrets.yaml", FASTAGENT_SECRETS_TEMPLATE, force
+    ):
+        created.append("fastagent.secrets.yaml")
+
+    if create_file(config_path / "agent.py", AGENT_EXAMPLE_TEMPLATE, force):
+        created.append("agent.py")
+
+    # Only create .gitignore if none exists in parent directories
+    if needs_gitignore and create_file(
+        config_path / ".gitignore", GITIGNORE_TEMPLATE, force
+    ):
+        created.append(".gitignore")
+
+    if created:
+        console.print("\n[green]Setup completed successfully![/green]")
+        if "fastagent-secrets.yaml" in created:
+            console.print("\n[yellow]Important:[/yellow] Remember to:")
+            console.print("1. Add your API keys to fastagent-secrets.yaml")
+            console.print(
+                "2. Keep fastagent-secrets.yaml secure and never commit it to version control"
+            )
+        console.print("\nTo get started, run:")
+        console.print("  uv run agent.py")
+    else:
+        console.print("\n[yellow]No files were created or modified.[/yellow]")

mcp_agent/cli/main.py

@@ -0,0 +1,68 @@
+"""Main CLI entry point for MCP Agent."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from mcp_agent.cli.terminal import Application
+from mcp_agent.cli.commands import setup, bootstrap
+
+app = typer.Typer(
+    help="MCP Agent CLI - Build effective agents using Model Context Protocol",
+    add_completion=False,  # We'll add this later when we have more commands
+)
+
+# Subcommands
+app.add_typer(setup.app, name="setup", help="Set up a new agent project")
+app.add_typer(bootstrap.app, name="bootstrap", help="Create example applications")
+
+# Shared application context
+application = Application()
+console = Console()
+
+
+def show_welcome():
+    """Show a welcome message with available commands."""
+    console.print("\n[bold]Welcome to MCP Agent![/bold]")
+    console.print("Build effective agents using Model Context Protocol (MCP)")
+
+    # Create a table for commands
+    table = Table(title="\nAvailable Commands")
+    table.add_column("Command", style="green")
+    table.add_column("Description")
+
+    table.add_row("setup", "Set up a new agent project with configuration files")
+    table.add_row(
+        "bootstrap", "Create example applications (decorator, researcher, etc.)"
+    )
+    # table.add_row("config", "Manage agent configuration settings")
+
+    console.print(table)
+
+    console.print("\n[bold]Getting Started:[/bold]")
+    console.print("1. Set up a new project:")
+    console.print("   mcp-agent setup")
+    console.print("\n2. Try an example:")
+    console.print("   mcp-agent bootstrap create decorator")
+    console.print("\nUse --help with any command for more information")
+    console.print("Example: mcp-agent bootstrap --help")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Disable output"),
+    color: bool = typer.Option(
+        True, "--color/--no-color", help="Enable/disable color output"
+    ),
+):
+    """MCP Agent CLI - Build effective agents using Model Context Protocol (MCP).
+
+    Use --help with any command for detailed usage information.
+    """
+    application.verbosity = 1 if verbose else 0 if not quiet else -1
+    application.console = application.console if color else None
+
+    # Show welcome message if no command was invoked
+    if ctx.invoked_subcommand is None:
+        show_welcome()

mcp_agent/cli/terminal.py

@@ -0,0 +1,24 @@
+from mcp_agent.console import console, error_console
+
+
+class Application:
+    def __init__(self, verbosity: int = 0, enable_color: bool = True):
+        self.verbosity = verbosity
+        # Use the central console instances, respecting color setting
+        if not enable_color:
+            # Create new instances without color if color is disabled
+            self.console = console.__class__(color_system=None)
+            self.error_console = error_console.__class__(color_system=None, stderr=True)
+        else:
+            self.console = console
+            self.error_console = error_console
+
+    def log(self, message: str, level: str = "info"):
+        if level == "info" or (level == "debug" and self.verbosity > 0):
+            if level == "error":
+                self.error_console.print(f"[{level.upper()}] {message}")
+            else:
+                self.console.print(f"[{level.upper()}] {message}")
+
+    def status(self, message: str):
+        return self.console.status(f"[bold cyan]{message}[/bold cyan]")