PHP MCP Server for Laravel

Um wrapper Laravel para a biblioteca php-mcp/server que expõe aplicações Laravel como servidores MCP.

Documentação

Laravel MCP Server SDK

Um SDK abrangente para Laravel para construir servidores Model Context Protocol (MCP) com recursos de nível empresarial e integrações nativas do Laravel.

Este SDK fornece um wrapper otimizado para Laravel da poderosa biblioteca php-mcp/server, permitindo que você exponha a funcionalidade da sua aplicação Laravel como Ferramentas (Tools), Recursos (Resources), Prompts e Modelos de Recursos (Resource Templates) MCP padronizados para assistentes de IA como Claude da Anthropic, Cursor IDE, ChatGPT da OpenAI e outros.

Principais Recursos

Integração Nativa com Laravel: Integração profunda com o container de serviços, configuração, cache, logging, sessões e console Artisan do Laravel
Definição Fluent de Elementos: Defina elementos MCP com uma API elegante no estilo Laravel usando o facade Mcp
Descoberta Baseada em Atributos: Use atributos PHP 8 (#[McpTool], #[McpResource], etc.) com descoberta automática e cache
Gerenciamento Avançado de Sessões: Handlers de sessão nativos do Laravel (arquivo, banco de dados, cache, redis) com coleta de lixo automática
Opções Flexíveis de Transporte:
- HTTP Integrado: Sirva através de rotas Laravel com suporte a middleware
- Servidor HTTP Dedicado: Servidor ReactPHP autônomo de alto desempenho
- STDIO: Interface de linha de comando para integração direta com clientes
Transporte Streamable: Transporte HTTP aprimorado com retomabilidade e event sourcing
Comandos Artisan: Comandos para servir, descoberta e gerenciamento de elementos
Cobertura Completa de Testes: Suíte de testes abrangente garantindo confiabilidade

Este pacote suporta a versão 2025-03-26 do Model Context Protocol.

Requisitos

PHP >= 8.1
Laravel >= 10.0
Extensões: json, mbstring, pcre (normalmente habilitadas por padrão)

Instalação

Instale o pacote via Composer:

composer require php-mcp/laravel:^3.0 -W

Publique o arquivo de configuração:

php artisan vendor:publish --provider="PhpMcp\Laravel\McpServiceProvider" --tag="mcp-config"

Para armazenamento de sessão em banco de dados, publique a migração:

php artisan vendor:publish --provider="PhpMcp\Laravel\McpServiceProvider" --tag="mcp-migrations"
php artisan migrate

Configuração

Todas as configurações do servidor MCP são gerenciadas através de config/mcp.php, que contém documentação abrangente para cada opção. A configuração cobre identidade do servidor, capacidades, configurações de descoberta, gerenciamento de sessão, opções de transporte, cache e logging. Todas as configurações suportam variáveis de ambiente para facilitar o gerenciamento de implantação.

As principais áreas de configuração incluem:

Informações do Servidor: Nome, versão e identidade básica
Capacidades: Controle quais recursos MCP estão habilitados (ferramentas, recursos, prompts, etc.)
Descoberta: Como os elementos são encontrados e armazenados em cache a partir do seu código
Gerenciamento de Sessão: Múltiplos backends de armazenamento (arquivo, banco de dados, cache, redis) com coleta de lixo automática
Transportes: Opções de STDIO, HTTP integrado e servidor HTTP dedicado
Desempenho: Estratégias de cache e limites de paginação

Revise o arquivo config/mcp.php publicado para documentação detalhada de todas as opções disponíveis e suas substituições por variáveis de ambiente.

Definindo Elementos MCP

O Laravel MCP fornece duas abordagens poderosas para definir elementos MCP: Registro Manual (usando o facade fluente Mcp) e Descoberta Baseada em Atributos (usando atributos PHP 8). Ambas podem ser combinadas, com registros manuais tendo precedência.

Tipos de Elementos

Ferramentas: Funções/ações executáveis (ex.: calculate, send_email, query_database)
Recursos: Conteúdo/dados estáticos acessíveis via URI (ex.: config://settings, file://readme.txt)
Modelos de Recursos: Recursos dinâmicos com padrões de URI (ex.: user://{id}/profile)
Prompts: Iniciadores/modelos de conversa (ex.: summarize, translate)

1. Registro Manual

Defina seus elementos MCP usando o elegante facade Mcp em routes/mcp.php:

<?php

use PhpMcp\Laravel\Facades\Mcp;
use App\Services\{CalculatorService, UserService, EmailService, PromptService};

// Register a simple tool
Mcp::tool([CalculatorService::class, 'add'])
    ->name('add_numbers')
    ->description('Add two numbers together');

// Register an invokable class as a tool
Mcp::tool(EmailService::class)
    ->description('Send emails to users');

// Register a closure as a tool with custom input schema
Mcp::tool(function(float $x, float $y): float {
    return $x * $y;
})
    ->name('multiply')
    ->description('Multiply two numbers')
    ->inputSchema([
        'type' => 'object',
        'properties' => [
            'x' => ['type' => 'number', 'description' => 'First number'],
            'y' => ['type' => 'number', 'description' => 'Second number'],
        ],
        'required' => ['x', 'y'],
    ]);

// Register a resource with metadata
Mcp::resource('config://app/settings', [UserService::class, 'getAppSettings'])
    ->name('app_settings')
    ->description('Application configuration settings')
    ->mimeType('application/json')
    ->size(1024);

// Register a closure as a resource
Mcp::resource('system://time', function(): string {
    return now()->toISOString();
})
    ->name('current_time')
    ->description('Get current server time')
    ->mimeType('text/plain');

// Register a resource template for dynamic content
Mcp::resourceTemplate('user://{userId}/profile', [UserService::class, 'getUserProfile'])
    ->name('user_profile')
    ->description('Get user profile by ID')
    ->mimeType('application/json');

// Register a closure as a resource template
Mcp::resourceTemplate('file://{path}', function(string $path): string {
    if (!file_exists($path) || !is_readable($path)) {
        throw new \InvalidArgumentException("File not found or not readable: {$path}");
    }
    return file_get_contents($path);
})
    ->name('file_reader')
    ->description('Read file contents by path')
    ->mimeType('text/plain');

// Register a prompt generator
Mcp::prompt([PromptService::class, 'generateWelcome'])
    ->name('welcome_user')
    ->description('Generate a personalized welcome message');

// Register a closure as a prompt
Mcp::prompt(function(string $topic, string $tone = 'professional'): array {
    return [
        [
            'role' => 'user',
            'content' => "Write a {$tone} summary about {$topic}. Make it informative and engaging."
        ]
    ];
})
    ->name('topic_summary')
    ->description('Generate topic summary prompts');

Métodos Fluent Disponíveis:

Para Todos os Elementos:

name(string $name): Substituir o nome inferido
description(string $description): Definir uma descrição personalizada

Para Ferramentas:

annotations(ToolAnnotations $annotations): Adicionar anotações de ferramenta MCP
inputSchema(array $schema): Definir esquema JSON personalizado para parâmetros

Para Recursos:

mimeType(string $mimeType): Especificar tipo de conteúdo
size(int $size): Definir tamanho do conteúdo em bytes
annotations(Annotations $annotations): Adicionar anotações MCP

Para Modelos de Recursos:

mimeType(string $mimeType): Especificar tipo de conteúdo
annotations(Annotations $annotations): Adicionar anotações MCP

Formatos de Handler:

[ClassName::class, 'methodName'] - Método de classe
InvokableClass::class - Classe invocável com método __invoke()
function(...) { ... } - Callables (v3.2+)

2. Descoberta Baseada em Atributos

Alternativamente, você pode usar atributos PHP 8 para marcar seus métodos ou classes como elementos MCP, caso em que você não precisa registrá-los em routes/mcp.php:

<?php

namespace App\Services;

use PhpMcp\Server\Attributes\{McpTool, McpResource, McpResourceTemplate, McpPrompt};

class UserService
{
    /**
     * Create a new user account.
     */
    #[McpTool(name: 'create_user')]
    public function createUser(string $email, string $password, string $role = 'user'): array
    {
        // Create user logic
        return [
            'id' => 123,
            'email' => $email,
            'role' => $role,
            'created_at' => now()->toISOString(),
        ];
    }

    /**
     * Get application configuration.
     */
    #[McpResource(
        uri: 'config://app/settings',
        mimeType: 'application/json'
    )]
    public function getAppSettings(): array
    {
        return [
            'theme' => config('app.theme', 'light'),
            'timezone' => config('app.timezone'),
            'features' => config('app.features', []),
        ];
    }

    /**
     * Get user profile by ID.
     */
    #[McpResourceTemplate(
        uriTemplate: 'user://{userId}/profile',
        mimeType: 'application/json'
    )]
    public function getUserProfile(string $userId): array
    {
        return [
            'id' => $userId,
            'name' => 'John Doe',
            'email' => 'john@example.com',
            'profile' => [
                'bio' => 'Software developer',
                'location' => 'New York',
            ],
        ];
    }

    /**
     * Generate a welcome message prompt.
     */
    #[McpPrompt(name: 'welcome_user')]
    public function generateWelcome(string $username, string $role = 'user'): array
    {
        return [
            [
                'role' => 'user',
                'content' => "Create a personalized welcome message for {$username} with role {$role}. Be warm and professional."
            ]
        ];
    }
}

Processo de Descoberta:

Elementos marcados com atributos são descobertos automaticamente quando:

auto_discover está habilitado na configuração (padrão: true)
Você executa php artisan mcp:discover manualmente

# Discover and cache MCP elements
php artisan mcp:discover

# Force re-discovery (ignores cache)
php artisan mcp:discover --force

# Discover without saving to cache
php artisan mcp:discover --no-cache

Precedência de Elementos

Registros manuais sempre substituem elementos descobertos com o mesmo identificador
Elementos descobertos são armazenados em cache para desempenho
Cache é invalidado automaticamente em novas execuções de descoberta

Executando o Servidor MCP

O Laravel MCP oferece três opções de transporte, cada uma otimizada para diferentes cenários de implantação:

1. Transporte STDIO

Melhor para: Execução direta pelo cliente, Cursor IDE, ferramentas de linha de comando

php artisan mcp:serve --transport=stdio

Configuração do Cliente (Cursor IDE):

{
    "mcpServers": {
        "my-laravel-app": {
            "command": "php",
            "args": [
                "/absolute/path/to/your/laravel/project/artisan",
                "mcp:serve",
                "--transport=stdio"
            ]
        }
    }
}

⚠️ Importante: Ao usar o transporte STDIO, nunca escreva em STDOUT em seus handlers (use o logger do Laravel ou STDERR para depuração). STDOUT é reservado para comunicação JSON-RPC.

2. Transporte HTTP Integrado

Melhor para: Desenvolvimento, aplicações com servidores web existentes, configuração rápida

O transporte integrado serve MCP através das rotas da sua aplicação Laravel:

// Routes are automatically registered at:
// GET  /mcp       - Streamable connection endpoint
// POST /mcp       - Message sending endpoint  
// DELETE /mcp     - Session termination endpoint

// Legacy mode (if enabled):
// GET  /mcp/sse   - Server-Sent Events endpoint
// POST /mcp/message - Message sending endpoint

Configuração de Proteção CSRF:

Adicione as rotas MCP às suas exclusões de CSRF:

Laravel 11+:

// bootstrap/app.php
->withMiddleware(function (Middleware $middleware) {
    $middleware->validateCsrfTokens(except: [
        'mcp',           // For streamable transport (default)
        'mcp/*',   // For legacy transport (if enabled)
    ]);
})

Laravel 10 e anteriores:

// app/Http/Middleware/VerifyCsrfToken.php
protected $except = [
    'mcp',           // For streamable transport (default)
    'mcp/*',   // For legacy transport (if enabled)
];

Opções de Configuração:

'http_integrated' => [
    'enabled' => true,
    'route_prefix' => 'mcp',           // URL prefix
    'middleware' => ['api'],           // Applied middleware
    'domain' => 'api.example.com',     // Optional domain
    'legacy' => false,                 // Use legacy SSE transport instead
],

Configuração do Cliente:

{
    "mcpServers": {
        "my-laravel-app": {
            "url": "https://your-app.test/mcp"
        }
    }
}

Considerações sobre o Ambiente do Servidor:

Servidores síncronos padrão têm dificuldade com conexões SSE persistentes, pois cada conexão ativa ocupa um processo de trabalho. Isso afeta tanto ambientes de desenvolvimento quanto de produção.

Para Desenvolvimento:

Servidor embutido do PHP (php artisan serve) não funcionará - o stream SSE trava o processo único
Laravel Herd (recomendado para desenvolvimento local)
Nginx configurado corretamente com múltiplos workers PHP-FPM
Laravel Octane com Swoole/RoadRunner para processamento assíncrono
Servidor HTTP dedicado (php artisan mcp:serve --transport=http)

Para Produção:

Servidor HTTP dedicado (fortemente recomendado)
Laravel Octane com Swoole/RoadRunner
Nginx configurado corretamente com workers PHP-FPM suficientes

3. Servidor HTTP Dedicado (Recomendado para Produção)

Melhor para: Ambientes de produção, aplicações de alto tráfego, múltiplos clientes concorrentes

Inicie um servidor HTTP autônomo baseado em ReactPHP:

# Start dedicated server
php artisan mcp:serve --transport=http

# With custom configuration
php artisan mcp:serve --transport=http \
    --host=0.0.0.0 \
    --port=8091 \
    --path-prefix=mcp_api

Opções de Configuração:

'http_dedicated' => [
    'enabled' => true,
    'host' => '127.0.0.1',              // Bind address
    'port' => 8090,                     // Port number
    'path_prefix' => 'mcp',             // URL path prefix
    'legacy' => false,                  // Use legacy transport
    'enable_json_response' => false,    // JSON mode vs SSE streaming
    'event_store' => null,              // Event store for resumability
    'ssl_context_options' => [],        // SSL configuration
],

Modos de Transporte:

Modo Streamable (legacy: false): Transporte aprimorado com retomabilidade e event sourcing
Modo Legado (legacy: true): Transporte HTTP+SSE obsoleto.

Modo de Resposta JSON:

'enable_json_response' => true,  // Returns immediate JSON responses
'enable_json_response' => false, // Uses SSE streaming (default)

Modo JSON: Retorna respostas imediatas, melhor para ferramentas de execução rápida
Modo SSE: Transmite respostas, ideal para operações de longa duração

Implantação em Produção:

Isso cria um processo de longa duração que deve ser gerenciado com:

Supervisor (recomendado)
systemd
Contêineres Docker
Gerenciadores de processos

Exemplo de configuração do Supervisor:

[program:laravel-mcp]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/laravel/artisan mcp:serve --transport=http
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=1
redirect_stderr=true
stdout_logfile=/var/log/laravel-mcp.log

Para guias abrangentes de implantação em produção, consulte a documentação do php-mcp/server.

Comandos Artisan

O Laravel MCP inclui vários comandos Artisan para gerenciar seu servidor MCP:

Comando de Descoberta

Descubra e armazene em cache elementos MCP do seu código:

# Discover elements and update cache
php artisan mcp:discover

# Force re-discovery (ignore existing cache)
php artisan mcp:discover --force

# Discover without updating cache
php artisan mcp:discover --no-cache

Exemplo de Saída:

Starting MCP element discovery...
Discovery complete.

┌─────────────────────┬───────┐
│ Element Type        │ Count │
├─────────────────────┼───────┤
│ Tools               │ 5     │
│ Resources           │ 3     │
│ Resource Templates  │ 2     │
│ Prompts             │ 1     │
└─────────────────────┴───────┘

MCP element definitions updated and cached.

Comando de Listagem

Visualize elementos MCP registrados:

# List all elements
php artisan mcp:list

# List specific type
php artisan mcp:list tools
php artisan mcp:list resources
php artisan mcp:list prompts
php artisan mcp:list templates

# JSON output
php artisan mcp:list --json

Exemplo de Saída:

Tools:
┌─────────────────┬──────────────────────────────────────────────┐
│ Name            │ Description                                  │
├─────────────────┼──────────────────────────────────────────────┤
│ add_numbers     │ Add two numbers together                     │
│ send_email      │ Send email to specified recipient            │
│ create_user     │ Create a new user account with validation    │
└─────────────────┴──────────────────────────────────────────────┘

Resources:
┌─────────────────────────┬───────────────────┬─────────────────────┐
│ URI                     │ Name              │ MIME                │
├─────────────────────────┼───────────────────┼─────────────────────┤
│ config://app/settings   │ app_settings      │ application/json    │
│ file://readme.txt       │ readme_file       │ text/plain          │
└─────────────────────────┴───────────────────┴─────────────────────┘

Comando de Servir

Inicie o servidor MCP com várias opções de transporte:

# Interactive mode (prompts for transport selection)
php artisan mcp:serve

# STDIO transport
php artisan mcp:serve --transport=stdio

# HTTP transport with defaults
php artisan mcp:serve --transport=http

# HTTP transport with custom settings
php artisan mcp:serve --transport=http \
    --host=0.0.0.0 \
    --port=8091 \
    --path-prefix=api/mcp

Opções do Comando:

--transport: Escolha o tipo de transporte (stdio ou http)
--host: Endereço do host para transporte HTTP
--port: Número da porta para transporte HTTP
--path-prefix: Prefixo do caminho da URL para transporte HTTP

Atualizações Dinâmicas & Eventos

O Laravel MCP integra-se ao sistema de eventos do Laravel para fornecer atualizações em tempo real aos clientes conectados:

Eventos de Mudança de Lista

Notifique os clientes quando seus elementos disponíveis mudarem:

use PhpMcp\Laravel\Events\{ToolsListChanged, ResourcesListChanged, PromptsListChanged};

// Notify clients that available tools have changed
ToolsListChanged::dispatch();

// Notify about resource list changes
ResourcesListChanged::dispatch();

// Notify about prompt list changes  
PromptsListChanged::dispatch();

Eventos de Atualização de Recursos

Notifique os clientes quando o conteúdo de um recurso específico mudar:

use PhpMcp\Laravel\Events\ResourceUpdated;

// Update a file and notify subscribers
file_put_contents('/path/to/config.json', json_encode($newConfig));
ResourceUpdated::dispatch('file:///path/to/config.json');

// Update database content and notify
User::find(123)->update(['status' => 'active']);
ResourceUpdated::dispatch('user://123/profile');

Recursos Avançados

Validação de Esquema

O servidor gera automaticamente esquemas JSON para parâmetros de ferramentas a partir de type hints e docblocks do PHP. Você pode aprimorar isso com o atributo #[Schema] para validação avançada:

use PhpMcp\Server\Attributes\Schema;

class PostService
{
    public function createPost(
        #[Schema(minLength: 5, maxLength: 200)]
        string $title,
        
        #[Schema(minLength: 10)]
        string $content,
        
        #[Schema(enum: ['draft', 'published', 'archived'])]
        string $status = 'draft',
        
        #[Schema(type: 'array', items: ['type' => 'string'])]
        array $tags = []
    ): array {
        return Post::create([
            'title' => $title,
            'content' => $content,
            'status' => $status,
            'tags' => $tags,
        ])->toArray();
    }
}

Recursos do Esquema:

Inferência automática a partir de type hints e docblocks do PHP
Validação em nível de parâmetro usando atributos #[Schema]
Suporte para restrições de string, faixas numéricas, enums, arrays e objetos
Funciona com registro manual e descoberta baseada em atributos

Para documentação abrangente de esquema e recursos avançados, consulte a documentação de Esquema do php-mcp/server.

Provedores de Completamento

Forneça sugestões de autocompletar para variáveis de modelos de recursos e argumentos de prompts para ajudar os usuários a descobrir opções disponíveis:

use PhpMcp\Server\Contracts\CompletionProviderInterface;
use PhpMcp\Server\Contracts\SessionInterface;
use PhpMcp\Server\Attributes\CompletionProvider;

class UserIdCompletionProvider implements CompletionProviderInterface
{
    public function getCompletions(string $currentValue, SessionInterface $session): array
    {
        return User::where('username', 'like', $currentValue . '%')
            ->limit(10)
            ->pluck('username')
            ->toArray();
    }
}

class UserService
{
    public function getUserData(
        #[CompletionProvider(UserIdCompletionProvider::class)]
        string $userId
    ): array {
        return User::where('username', $userId)->first()->toArray();
    }
}

Recursos de Completamento:

Autocompletar para variáveis de modelos de recursos e argumentos de prompts
Integração com Laravel - use modelos Eloquent, coleções, etc.
Ciente de sessão - os completamentos podem variar com base na sessão do usuário
Filtragem em tempo real com base na entrada do usuário

Para documentação detalhada de provedores de completamento, consulte a documentação de Completamento do php-mcp/server.

Injeção de Dependência

Seus handlers MCP se beneficiam automaticamente do container de serviços do Laravel:

class OrderService
{
    public function __construct(
        private PaymentGateway $gateway,
        private NotificationService $notifications,
        private LoggerInterface $logger
    ) {}

    #[McpTool(name: 'process_order')]
    public function processOrder(array $orderData): array
    {
        $this->logger->info('Processing order', $orderData);
        
        $payment = $this->gateway->charge($orderData['amount']);
        
        if ($payment->successful()) {
            $this->notifications->sendOrderConfirmation($orderData['email']);
            return ['status' => 'success', 'order_id' => $payment->id];
        }
        
        throw new \Exception('Payment failed: ' . $payment->error);
    }
}

Tratamento de Exceções

Handlers de ferramentas podem lançar exceções que são automaticamente convertidas em respostas de erro JSON-RPC adequadas:

#[McpTool(name: 'get_user')]
public function getUser(int $userId): array
{
    $user = User::find($userId);
    
    if (!$user) {
        throw new \InvalidArgumentException("User with ID {$userId} not found");
    }
    
    if (!$user->isActive()) {
        throw new \RuntimeException("User account is deactivated");
    }
    
    return $user->toArray();
}

Logging e Depuração

Configure logging abrangente para seu servidor MCP:

// config/mcp.php
'logging' => [
    'channel' => 'mcp',  // Use dedicated log channel
    'level' => 'debug',  // Set appropriate log level
],

Crie um canal de log dedicado em config/logging.php:

'channels' => [
    'mcp' => [
        'driver' => 'daily',
        'path' => storage_path('logs/mcp.log'),
        'level' => env('MCP_LOG_LEVEL', 'info'),
        'days' => 14,
    ],
],

Guia de Migração

Da v3.0 para v3.1

Novos Tipos de Handler:

O Laravel MCP v3.1 introduz suporte para handlers de closure, expandindo além de apenas métodos de classe e classes invocáveis:

// v3.0 and earlier - Class-based handlers only
Mcp::tool([CalculatorService::class, 'add'])
    ->name('add_numbers');

Mcp::tool(EmailService::class)  // Invokable class
    ->name('send_email');

// v3.1+ - Now supports closures
Mcp::tool(function(float $x, float $y): float {
    return $x * $y;
})
    ->name('multiply')
    ->description('Multiply two numbers');

Mcp::resource('system://time', function(): string {
    return now()->toISOString();
})
    ->name('current_time');

Suporte a Esquema de Entrada:

Ferramentas agora podem definir esquemas JSON personalizados para validação de parâmetros:

// v3.1+ - Custom input schema
Mcp::tool([CalculatorService::class, 'calculate'])
    ->inputSchema([
        'type' => 'object',
        'properties' => [
            'operation' => [
                'type' => 'string',
                'enum' => ['add', 'subtract', 'multiply', 'divide']
            ],
            'numbers' => [
                'type' => 'array',
                'items' => ['type' => 'number'],
                'minItems' => 2
            ]
        ],
        'required' => ['operation', 'numbers']
    ]);

Métodos Blueprint Aprimorados:

Novos métodos fluentes disponíveis em blueprints:

->inputSchema(array $schema)  // Define custom parameter schema

Sem Mudanças de Quebra:

Todo o código existente da v3.0 continua funcionando sem modificação. Os novos recursos são aprimoramentos aditivos.

Da v2.x para v3.x

Mudanças de Configuração:

// Old structure
'capabilities' => [
    'tools' => ['enabled' => true, 'listChanged' => true],
    'resources' => ['enabled' => true, 'subscribe' => true],
],

// New structure  
'capabilities' => [
    'tools' => true,
    'toolsListChanged' => true,
    'resources' => true,
    'resourcesSubscribe' => true,
],

Configuração de Sessão:

// Old: Basic configuration
'session' => [
    'driver' => 'cache',
    'ttl' => 3600,
],

// New: Enhanced configuration
'session' => [
    'driver' => 'cache',
    'ttl' => 3600,
    'store' => config('cache.default'),
    'lottery' => [2, 100],
],

Atualizações de Transporte:

Transporte padrão alterado de sse para streamable
Novo padrão de exclusão CSRF: mcp em vez de mcp/*
Gerenciamento de sessão aprimorado com coleta de lixo automática

Mudanças de Quebra:

Métodos obsoletos removidos em favor da nova API de registro
Registro de elementos atualizado para usar o novo formato de esquema
Estrutura de configuração alterada para melhor organização

Exemplos & Casos de Uso

Integração de E-commerce

class EcommerceService
{
    #[McpTool(name: 'get_product_info')]
    public function getProductInfo(int $productId): array
    {
        return Product::with(['category', 'reviews'])
            ->findOrFail($productId)
            ->toArray();
    }

    #[McpTool(name: 'search_products')]
    public function searchProducts(
        string $query,
        ?string $category = null,
        int $limit = 10
    ): array {
        return Product::search($query)
            ->when($category, fn($q) => $q->where('category', $category))
            ->limit($limit)
            ->get()
            ->toArray();
    }

    #[McpResource(uri: 'config://store/settings', mimeType: 'application/json')]
    public function getStoreSettings(): array
    {
        return [
            'currency' => config('store.currency'),
            'tax_rate' => config('store.tax_rate'),
            'shipping_zones' => config('store.shipping_zones'),
        ];
    }
}

Gerenciamento de Conteúdo

class ContentService
{
    #[McpResourceTemplate(uriTemplate: 'post://{slug}', mimeType: 'text/markdown')]
    public function getPostContent(string $slug): string
    {
        return Post::where('slug', $slug)
            ->firstOrFail()
            ->markdown_content;
    }

    #[McpPrompt(name: 'content_summary')]
    public function generateContentSummary(string $postSlug, int $maxWords = 50): array
    {
        $post = Post::where('slug', $postSlug)->firstOrFail();
        
        return [
            [
                'role' => 'user',
                'content' => "Summarize this blog post in {$maxWords} words or less:\n\n{$post->content}"
            ]
        ];
    }
}

Integração de API

class ApiService
{
    #[McpTool(name: 'send_notification')]
    public function sendNotification(
        #[Schema(format: 'email')]
        string $email,
        
        string $subject,
        string $message
    ): array {
        $response = Http::post('https://api.emailservice.com/send', [
            'to' => $email,
            'subject' => $subject,
            'body' => $message,
        ]);

        if ($response->failed()) {
            throw new \RuntimeException('Failed to send notification: ' . $response->body());
        }

        return $response->json();
    }
}

Contribuindo

Aceitamos contribuições! Consulte CONTRIBUTING.md para diretrizes.

Configuração de Desenvolvimento

# Clone the repository
git clone https://github.com/php-mcp/laravel.git
cd laravel

# Install dependencies
composer install

# Run tests
./vendor/bin/pest

# Check code style
./vendor/bin/pint

Licença

A Licença MIT (MIT). Consulte LICENSE para detalhes.

Agradecimentos

Construído sobre a especificação Model Context Protocol
Alimentado por php-mcp/server para funcionalidade central do MCP
Utiliza recursos do framework Laravel para integração perfeita
Usa ReactPHP para operações assíncronas de alto desempenho