Skip to main content

What is MCP?

Model Context Protocol (MCP) is like “USB-C for AI applications” - a universal standard that lets your agents connect to external data sources and tools. Instead of building custom integrations for every service, you can use the growing ecosystem of MCP servers!

File Systems

Read, write, search files and directories with full filesystem access

GitHub Integration

Create issues, manage repos, read code, and automate workflows

Databases

Query PostgreSQL, MySQL, and other databases directly from agents

Web Search

Search the web with Brave Search for real-time information

Team Tools

Integrate with Slack, Discord, and other communication platforms

Custom Servers

Build your own MCP servers in any language for specialized needs

Quick Start - Add MCP in 60 Seconds

Getting MCP working with your agents is incredibly simple. Here’s how:

1. Install MCP Server

Terminal
npm install -g @modelcontextprotocol/server-filesystem

2. Configure in Vizra

config/vizra-adk.php
'mcp_servers' => [
    'filesystem' => [
        'command' => 'npx',
        'args' => [
            '@modelcontextprotocol/server-filesystem',
            storage_path('app'), // Allow access to storage directory
        ],
        'enabled' => true,
    ],
],

3. Create MCP-Enabled Agent

app/Agents/FileManagerAgent.php
<?php
namespace App\Agents;

use Vizra\VizraADK\Agents\BaseLlmAgent;

class FileManagerAgent extends BaseLlmAgent
{
    protected string $name = 'file_manager';
    protected string $instructions = 'You can read, write, and manage files. Help users with file operations!';

    protected array $mcpServers = ['filesystem'];
}

4. Test It Out!

Terminal
php artisan vizra:chat file_manager
That’s It! Your agent now has access to all filesystem tools! It can read files, write content, search directories, and more. The MCP tools are automatically discovered and added to your agent.

Available MCP Servers

Here are some popular MCP servers you can use right away:

Filesystem Server

Access local files and directories with comprehensive file operations.

Installation

npm install -g @modelcontextprotocol/server-filesystem

Configuration

'filesystem' => [
    'command' => 'npx',
    'args' => ['@modelcontextprotocol/server-filesystem', '/safe/path'],
    'enabled' => true,
],
Available Tools:
  • read_file - Read file contents
  • write_file - Write to files
  • list_directory - List directory contents
  • search_files - Search for files and content

GitHub Server

Comprehensive GitHub integration for repository management and automation.

Installation

npm install -g @modelcontextprotocol/server-github

Configuration

'github' => [
    'command' => 'npx',
    'args' => ['@modelcontextprotocol/server-github', '--token', env('GITHUB_TOKEN')],
    'enabled' => !empty(env('GITHUB_TOKEN')),
],
Available Tools:
  • create_issue - Create GitHub issues
  • search_repositories - Search repos
  • get_file_contents - Read files from repos
  • list_issues - List repository issues

PostgreSQL Server

Direct database access for queries and data manipulation.

Installation

npm install -g @modelcontextprotocol/server-postgres

Configuration

'postgres' => [
    'command' => 'npx',
    'args' => ['@modelcontextprotocol/server-postgres', '--connection-string', env('DATABASE_URL')],
    'enabled' => !empty(env('DATABASE_URL')),
],
Available Tools:
  • query - Execute SQL queries
  • describe_table - Get table schema
  • list_tables - List all tables
  • get_schema - Get database schema

Advanced Configuration

Transport Types

Vizra ADK supports two transport types for MCP servers:

STDIO Transport (Default)

Local MCP servers running as subprocesses. Best for filesystem, local databases, and npm packages.
'filesystem' => [
    'transport' => 'stdio', // Default
    'command' => 'npx',
    'args' => ['@modelcontextprotocol/server-filesystem'],
    'enabled' => true,
],

HTTP Transport

Remote MCP servers via HTTP/SSE. Perfect for cloud services, microservices, and shared resources.
'github_remote' => [
    'transport' => 'http',
    'url' => 'https://mcp.example.com/api',
    'api_key' => env('MCP_API_KEY'),
    'enabled' => true,
],

Environment-Based Setup

Use environment variables to control MCP servers across different environments:
.env
# Enable/disable servers per environment
MCP_FILESYSTEM_ENABLED=true
MCP_GITHUB_ENABLED=true
MCP_POSTGRES_ENABLED=false

# Server-specific configuration
GITHUB_TOKEN=your_github_token_here
DATABASE_URL=postgresql://user:pass@localhost/db
BRAVE_API_KEY=your_brave_search_key
MCP_NPX_PATH="/path/to/npx"  # Optional: specify npx path if not in PATH
config/vizra-adk.php
'mcp_servers' => [
    'filesystem' => [
        'command' => 'npx',
        'args' => ['@modelcontextprotocol/server-filesystem', storage_path('app')],
        'enabled' => env('MCP_FILESYSTEM_ENABLED', false),
        'timeout' => 30,
    ],

    'github' => [
        'command' => 'npx',
        'args' => ['@modelcontextprotocol/server-github', '--token', env('GITHUB_TOKEN')],
        'enabled' => env('MCP_GITHUB_ENABLED', false) && !empty(env('GITHUB_TOKEN')),
        'timeout' => 45,
    ],

    'postgres' => [
        'command' => 'npx',
        'args' => ['@modelcontextprotocol/server-postgres', '--connection-string', env('DATABASE_URL')],
        'enabled' => env('MCP_POSTGRES_ENABLED', false) && !empty(env('DATABASE_URL')),
        'timeout' => 30,
    ],
],

Multiple Servers per Agent

Agents can use multiple MCP servers simultaneously:
Multi-Server Agent
class DeveloperAssistantAgent extends BaseLlmAgent
{
    protected string $name = 'developer_assistant';

    protected string $instructions = 'You are a comprehensive development assistant with access to:

    **File System**: Read, write, and search project files
    **GitHub**: Manage repositories, issues, and pull requests
    **Database**: Query and analyze data directly

    Use these tools together to provide powerful development support!';

    protected array $mcpServers = ['filesystem', 'github', 'postgres'];
}

Management Commands

Vizra ADK provides helpful commands to manage your MCP integration:
Terminal
# List configured servers and their status
php artisan vizra:mcp:servers

# Test connections and show available tools from each server
php artisan vizra:mcp:servers --test

Real-World Examples

Code Review Assistant

Code Review Agent
class CodeReviewAgent extends BaseLlmAgent
{
    protected string $name = 'code_reviewer';

    protected string $instructions = 'You are an expert code reviewer. You can:

    1. Read code files to understand implementations
    2. Search for patterns and potential issues
    3. Create GitHub issues for problems found
    4. Suggest improvements and best practices

    Always provide constructive feedback with specific examples.';

    protected array $mcpServers = ['filesystem', 'github'];
}
Example Conversation:
  • User: “Review the authentication code in src/Auth/”
  • Agent: “I’ll examine the authentication code for you…”
    • Uses filesystem tools to read auth files
    • Analyzes code for security issues
    • Creates GitHub issue for potential vulnerability
  • Agent: “Found 3 areas for improvement. Created issue #42 for the critical security concern.”

Data Analysis Assistant

Data Analysis Agent
class DataAnalystAgent extends BaseLlmAgent
{
    protected string $name = 'data_analyst';

    protected string $instructions = 'You are a data analysis expert. You can:

    1. Query databases to extract insights
    2. Generate reports and save them as files
    3. Create data visualizations and charts
    4. Identify trends and anomalies in data

    Always explain your analysis methodology and findings clearly.';

    protected array $mcpServers = ['postgres', 'filesystem'];
}

Security Best Practices

Filesystem Security
  • Limit directory access - Only allow access to safe directories
  • Use storage paths - Prefer storage_path() over system directories
  • Validate file operations - MCP servers should validate all file paths
  • Monitor file access - Log all file operations for audit trails
API Token Security
  • Use environment variables - Never hardcode tokens in config
  • Minimal permissions - Grant only necessary API permissions
  • Rotate tokens regularly - Set up token rotation schedules
  • Monitor usage - Track API calls and unusual activity
Environment Isolation
  • Separate configs - Different MCP servers for dev/staging/prod
  • Sandbox testing - Test MCP integrations in isolated environments
  • Resource limits - Set appropriate timeouts and resource constraints
  • Error handling - Graceful degradation when MCP servers are unavailable

Troubleshooting

Server Connection Failed

Error: “Failed to start MCP server”
  • Check that the MCP server package is installed globally
  • Verify the command path and arguments in config
  • Run php artisan vizra:mcp:servers --test for details

Tools Not Available

Error: “Tool not found” or tools not appearing
  • Ensure the server is enabled in configuration
  • Check that the mcpServers property includes the server
  • Clear cache and restart the application

Permission Denied

Error: “Access denied” or “Insufficient permissions”
  • Check filesystem permissions for directory access
  • Verify API tokens have necessary permissions
  • Ensure environment variables are set correctly

Best Practices

Agent Design

  • Single responsibility - Each agent should have a clear, focused purpose
  • Appropriate tools - Only include MCP servers the agent actually needs
  • Clear instructions - Explain what MCP capabilities the agent has
  • Error handling - Handle MCP failures gracefully in agent instructions

Performance

  • Cache wisely - MCP tool discovery is cached for 5 minutes
  • Connection pooling - MCP clients are reused across requests
  • Timeout settings - Set appropriate timeouts for different server types
  • Monitor usage - Track MCP server performance and availability

Development Workflow

  • Test locally first - Use --test flag to verify servers
  • Gradual rollout - Enable MCP servers incrementally
  • Monitor logs - Watch for MCP-related errors and performance issues
  • Documentation - Document which agents use which MCP servers

MCP Opens Infinite Possibilities

Your agents can now connect to any data source or service in the MCP ecosystem.