> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP y conectores

> Usa ServerRpc en Laravel Copilot SDK para gestionar la configuración de MCP y los conectores, registrar máscaras de secretos y ejecutar comprobaciones de OAuth de MCP.

## MCP y conectores

Ámbito: ServerRpc (operaciones de todo el servidor vinculadas al Client)

Para una visión general de RPC y la lista de todas las páginas de RPC, consulta [RPC](https://kawax.biz/es/packages/laravel-copilot-sdk/rpc.md).

```php theme={null}
use Revolution\Copilot\Enums\McpInstallationSecretStorage;
use Revolution\Copilot\Enums\OptionsUpdateToolFilterPrecedence;
use Revolution\Copilot\Types\Rpc\CatalogClientContract;
use Revolution\Copilot\Types\Rpc\McpApplyInstallRequest;
use Revolution\Copilot\Types\Rpc\McpApplyUninstallRequest;
use Revolution\Copilot\Types\Rpc\McpInstallationOperationRequest;
use Revolution\Copilot\Types\Rpc\McpInstallationsRequest;
use Revolution\Copilot\Types\Rpc\McpPlanUninstallRequest;
use Revolution\Copilot\Types\Rpc\McpPrepareInstallRequest;
use Revolution\Copilot\Types\Rpc\McpRegistryCancelRequest;
use Revolution\Copilot\Types\Rpc\McpRegistrySearchRequest;
use Revolution\Copilot\Types\Rpc\McpServerCardReference;
use Revolution\Copilot\Types\Rpc\McpShouldExcludeGitHubToolsRequest;

// mcp config (gestión de la configuración de servidores MCP)
Copilot::client()->rpc()->mcp()->list();
Copilot::client()->rpc()->mcp()->add(new McpConfigAddRequest(
    name: 'my-server',
    config: new McpServerValue(type: 'local', command: 'php', args: ['artisan', 'mcp']),
));
// args es opcional
Copilot::client()->rpc()->mcp()->update(new McpConfigUpdateRequest(
    name: 'my-server',
    config: new McpServerValue(type: 'http', url: 'https://mcp.example.com'),
));
Copilot::client()->rpc()->mcp()->remove(new McpConfigRemoveRequest(name: 'my-server'));
// Activar/desactivar servidores MCP (configuración global)
Copilot::client()->rpc()->mcp()->enable(new McpConfigEnableRequest(names: ['my-server']));
Copilot::client()->rpc()->mcp()->disable(new McpConfigDisableRequest(names: ['my-server']));
// Limpiar la caché en memoria (se vuelve a leer desde disco en la próxima carga)
Copilot::client()->rpc()->mcp()->reload();

// Búsqueda en el registro MCP (experimental/internal)
// $authInfo es la información de autenticación JSON preparada por el host. El SDK no interpreta su contenido.

$registry = Copilot::client()->rpc()->mcp()->registry();
$requestId = $registry->allocateRequestId()->requestId;
$servers = $registry->search(new McpRegistrySearchRequest(
    requestId: $requestId,
    authInfo: $authInfo, // Información de autenticación pasada desde el host. El SDK no interpreta su contenido.
    query: 'database',
    limit: 20,
));
// $servers->servers son los datos de servidores del registro (se conservan sin interpretar su forma)
// Los ID reservados sin usar se pueden liberar. Una búsqueda en curso se cancela llamando a cancel() desde otro proceso.
$unusedRequestId = $registry->allocateRequestId()->requestId;
$cancelResult = $registry->cancel(new McpRegistryCancelRequest(requestId: $unusedRequestId));
// Al liberar un ID sin usar, canceled es false. Solo es true si se detuvo una búsqueda en ejecución.

// Instalación / desinstalación a través del catálogo MCP (experimental)
// El resultado es un array asociativo de unión discriminada con kind. Comprueba kind antes de acceder a cada campo.

$mcp = Copilot::client()->rpc()->mcp();
$contract = new CatalogClientContract(
    protocolVersion: 1,
    requiredCapabilities: ['mcp-server-card', 'mcp-install-planning'],
);

// $candidateHandle, $searchId y $cardReference se obtienen de los resultados de búsqueda del catálogo.
// $sessionId es el ID de una sesión ya conectada a este Client.
$planned = $mcp->planInstall([
    'contract' => $contract->toArray(),
    'source' => ['kind' => 'candidate', 'candidateHandle' => $candidateHandle, 'searchId' => $searchId],
]);

if (($planned['kind'] ?? null) === 'planned') {
    $plan = $planned['plan'];
    $prepared = $mcp->prepareInstall(new McpPrepareInstallRequest(
        contract: $contract,
        planHandle: $plan['planHandle'],
        choiceId: $plan['transportChoices'][0]['choiceId'],
        inputs: [],
        policySessionId: $sessionId,
        secrets: [],
        secretStorage: McpInstallationSecretStorage::Keychain,
        source: McpServerCardReference::fromArray($cardReference),
    ));

    // Durante applyInstall se invoca el installation_confirmation_handler configurado al crear el cliente.
    if (($prepared['kind'] ?? null) === 'outcome'
        && ($prepared['outcome']['kind'] ?? null) === 'install-prepared') {
        $applied = $mcp->applyInstall(new McpApplyInstallRequest(
            contract: $contract,
            operationId: $prepared['outcome']['operation']['operationId'],
            policySessionId: $sessionId,
        ));
    }
}

// Listar las instalaciones propias y recuperar operaciones sin completar
$installations = $mcp->installations();
$installations->list(new McpInstallationsRequest(contract: $contract, policySessionId: $sessionId));
$installations->recover(new McpInstallationsRequest(contract: $contract, policySessionId: $sessionId));
$installations->status(new McpInstallationOperationRequest($contract, $operationId));
$installations->cancel(new McpInstallationOperationRequest($contract, $operationId));

// La desinstalación se planifica indicando un installationId del que se es propietario y se aplica el planHandle devuelto.
$uninstallPlan = $mcp->planUninstall(new McpPlanUninstallRequest(
    contract: $contract,
    installationId: $installationId,
    policySessionId: $sessionId,
));
if (($uninstallPlan['kind'] ?? null) === 'outcome'
    && ($uninstallPlan['outcome']['kind'] ?? null) === 'uninstall-planned') {
    $mcp->applyUninstall(new McpApplyUninstallRequest(
        contract: $contract,
        planHandle: $uninstallPlan['outcome']['plan']['planHandle'],
        policySessionId: $sessionId,
    ));
}

// Determinar si se pueden excluir las herramientas MCP de GitHub (experimental/internal)

$exclude = Copilot::client()->rpc()->mcp()->shouldExcludeGitHubTools(
    new McpShouldExcludeGitHubToolsRequest(
        availableTools: ['builtin:bash'],
        excludedTools: [],
        toolFilterPrecedence: OptionsUpdateToolFilterPrecedence::Available,
    ),
)->excludeGhReplaceableTools;

// mcp discover (descubrir automáticamente servidores MCP)
Copilot::client()->rpc()->mcp()->discover(new McpDiscoverRequest(
    workingDirectory: '/path/to/project',
));
// Se puede ejecutar sin argumentos
$result = Copilot::client()->rpc()->mcp()->discover();
// $result->servers es un array de DiscoveredMcpServer
```

## secrets (experimental: registrar máscaras para secretos dinámicos)

El método experimental `secrets()->addFilterValues()` registra en el filtro de redacción del CLI los secretos dinámicos generados por tu host. A partir de ahí, el CLI enmascara esos valores en los logs de sesión y en las exportaciones.

```php theme={null}
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\Rpc\SecretsAddFilterValuesRequest;

$result = Copilot::client()->rpc()->secrets()->addFilterValues(
    new SecretsAddFilterValuesRequest(values: [$accessToken]),
);
// $result->ok

// También se puede pasar un array
Copilot::client()->rpc()->secrets()->addFilterValues([
    'values' => [$accessToken],
]);
```

Esta RPC no obtiene tokens OAuth. El SDK no persiste los valores ni los escribe en logs adicionales. Registra valores que tu host ya haya obtenido.

## mcp oauth (comprobaciones previas de OAuth de MCP)

Después de que un servidor MCP remoto solicite autenticación OAuth, puedes comprobar si admite Dynamic Client Registration (DCR). Se devuelve `authorizationServerUrl` cuando el servidor de autorización puede descubrirse a partir de los metadatos. Si `supportsDcr` es `false`, el registro dinámico no está disponible. También puedes comprobar si el servidor de autorización es de Microsoft.

```php theme={null}
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\Rpc\McpOauthCheckDcrSupportRequest;
use Revolution\Copilot\Types\Rpc\McpOauthIsMicrosoftAuthorizationServerRequest;

$oauth = Copilot::client()->rpc()->mcp()->oauth();

$dcr = $oauth->checkDcrSupport(new McpOauthCheckDcrSupportRequest(
    serverUrl: 'https://mcp.example.com',
    resourceMetadataText: $challengeMetadata,
    sessionId: $session->id(),
));

$isMicrosoft = $dcr->authorizationServerUrl === null
    ? false
    : $oauth->isMicrosoftAuthorizationServer(new McpOauthIsMicrosoftAuthorizationServerRequest(
        authorizationServerUrl: $dcr->authorizationServerUrl,
    ))->isMicrosoftAuthorizationServer;
```


## Related topics

- [Resumen de ServerRpc](https://kawax.biz/es/packages/laravel-copilot-sdk/rpc/server-overview.md)
- [RPC (Remote Procedure Call)](https://kawax.biz/es/packages/laravel-copilot-sdk/rpc.md)
- [MCP](https://kawax.biz/es/packages/laravel-copilot-sdk/mcp.md)
- [Resumen de SessionRpc](https://kawax.biz/es/packages/laravel-copilot-sdk/rpc/session-overview.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.