LocalCloud MCP

Entorno de nube local gratuito para que agentes de IA construyan, prueben y depuren aplicaciones de Google Cloud. CLI 0.1.9+. Sitio web: https://local.cloud/ Guía: https://local.cloud/docs/mcp/

GitHubPrueba este MCPPatrocinado

Documentación

LocalCloud MCP: un entorno de nube local para agentes de IA

LocalCloud brinda a los agentes de codificación de IA un entorno de nube local gratuito para crear, probar y depurar aplicaciones de Google Cloud. Su servidor MCP conecta a los agentes con el descubrimiento de servicios, la configuración del SDK, la inspección de recursos, las consultas de datos, las verificaciones de disponibilidad y los diagnósticos. El código de la aplicación utiliza los SDK estándar de Google Cloud apuntando al entorno de ejecución local.

Inicie el entorno con un solo comando, cree proyectos locales para experimentos y pruebas, y ejecute flujos de trabajo de servicios locales sin cargos por servicios de Google Cloud. El inicio inicial puede descargar la imagen; la capacidad del proyecto depende de su máquina. Para los complementos de Claude y Codex, consulte la guía de instalación del marketplace.

Sitio web · Guía de MCP del sitio web · Código fuente · Versiones

Inicio rápido

Requisitos: motor Docker, CLI de LocalCloud e imagen de Docker de LocalCloud. La CLI se ejecuta de forma nativa en macOS y Linux, incluye el puente MCP y obtiene la imagen cuando es necesario. No se requiere instalación separada del servidor MCP ni cuenta de Google Cloud para los flujos de trabajo locales.

Instalar LocalCloud

En macOS, o Linux con Homebrew:

brew install LocalGCloud/tap/localcloud
lc --version
lc doctor

Para una instalación existente de Homebrew, ejecute brew update y brew upgrade localcloud para usar la CLI actual.

En macOS o Linux sin Homebrew:

curl -fsSL https://local.cloud/install.sh | sh
localcloud --version
localcloud doctor

La página de versiones también proporciona archivos independientes firmados para macOS ARM64/x86_64 y Linux ARM64/x86_64. Los binarios de macOS requieren macOS 13 o posterior; los binarios de Linux requieren glibc 2.35 o posterior. No se distribuyen binarios nativos de Windows; los usuarios de Windows necesitan un entorno Linux/WSL adecuado y una configuración de lanzamiento del cliente que pueda alcanzarlo.

Conectar un agente

Para Cursor:

lc mcp install --client cursor

Recargue el cliente y habilite el servidor MCP localcloud. El puente inicia o reutiliza el entorno de ejecución automáticamente. La primera conexión puede tardar más mientras Docker descarga la imagen del entorno de ejecución. Para iniciarlo deliberadamente con puertos vinculados a localhost antes de conectar:

lc start --local-only

Para Claude Code, use lc mcp install --client claude-code; para Claude Desktop, use lc mcp install --client claude-desktop. Otras configuraciones de cliente se describen a continuación.

Entornos existentes y actualizaciones

Use la CLI y la imagen actuales de LocalCloud juntas. Conectar MCP o actualizar la CLI reutiliza un contenedor existente; no reemplaza un entorno de ejecución anterior. Si un cliente estricto rechaza un esquema de herramienta, actualice deliberadamente el entorno de ejecución seleccionado y vuelva a conectar.

Inspeccione lc status. Para actualizar deliberadamente el entorno de ejecución seleccionado conservando su volumen de datos con nombre:

lc restart --image agentcloud/localcloud:latest --pull

Incluya el mismo --data-volume y archivo de configuración que usa normalmente si apunta a un entorno personalizado. El reinicio interrumpe brevemente a los clientes; vuelva a conectar después.

Paquete de escritorio

Los clientes que admiten extensiones de escritorio MCP pueden obtener el paquete LocalCloud MCP desde los recursos de la versión. Incluye la CLI nativa; el motor Docker y la imagen de LocalCloud siguen siendo necesarios. Siga el flujo de instalación de extensiones del cliente y luego habilite LocalCloud MCP. Los metadatos del registro registran el hash del artefacto seleccionado y los requisitos previos. Los complementos del marketplace de Claude y Codex usan la CLI instalada por separado.

Completar una primera tarea

Dé al agente este mensaje:

Use el servidor MCP de LocalCloud. Enumere los servicios locales, verifique la disponibilidad y obtenga el entorno del SDK para este proyecto. Inspeccione la información de compatibilidad antes de escribir una pequeña prueba de integración de Google Cloud. Use solo los endpoints locales devueltos; deténgase si una operación requerida no está disponible. No solicite credenciales reales de Google Cloud ni recurra a Google Cloud real.

Un cliente conectado debería descubrir localcloud_list_services, localcloud_check_readiness y localcloud_get_env. Para una primera llamada de herramienta, use localcloud_list_services con {}. Luego llame a localcloud_get_env con {"format":"json"}. Lea los valores de endpoint devueltos en lugar de asumir puertos predeterminados.

Lo que los agentes pueden hacer

Flujo de trabajoSoporte MCPFlujo de trabajo de la aplicación
Crear una función de almacenamiento y mensajeríaDescubrir Cloud Storage/Pub/Sub, obtener endpoints del SDK, inspeccionar recursos y solicitudes recientesSubir un objeto de prueba, publicar un mensaje, consumirlo y verificar el resultado usando SDK estándar
Inspeccionar y consultar datos localesExplorar recursos, verificar perfiles de conexión de bases de datos, ejecutar consultas compatiblesExplorar un conjunto de datos y ejecutar una consulta determinista de BigQuery
Escribir una prueba de integración repetibleLeer compatibilidad, configuración de SDK/Terraform, recetas y mensajes de pruebaCrear solo recursos propiedad de la prueba, verificar resultados y limpiarlos a través del SDK
Diagnosticar una falla de la aplicaciónVerificar disponibilidad, diagnósticos, registros y solicitudes recientesIdentificar un problema de endpoint, esquema o disponibilidad del servicio y volver a ejecutar la prueba fallida

Ejecute los tres flujos de trabajo reproducibles de MCP y SDK, o comience con ejemplos de SDK, guía de Terraform y el punto de entrada del agente. La compatibilidad de LocalCloud es específica del servicio y la operación; valide el comportamiento de la versión contra Google Cloud real por separado.

Permisos y datos locales

Las operaciones de gestión MCP de escritura y destructivas están controladas por la configuración del entorno de ejecución LOCALCLOUD_MCP_WRITE y LOCALCLOUD_MCP_DESTRUCTIVE, ambas deshabilitadas de forma predeterminada. Estas son configuraciones del entorno de ejecución, no permisos habilitados por lc mcp install. El cliente instalado inicia el puente; no otorga privilegios adicionales del entorno de ejecución. Las operaciones del SDK aún pueden cambiar los datos de la aplicación local, así que use recursos propiedad de la prueba y limpieza explícita.

El volumen de datos predeterminado se comparte entre clientes y repositorios. Un ID de proyecto selecciona un proyecto lógico; no es un límite de seguridad estricto entre agentes. Use un volumen de datos separado cuando se necesite un entorno de ejecución independiente. Revise privacidad y comportamiento de salida y la licencia aplicable para el artefacto que instale. LocalCloud es gratuito para los flujos de trabajo de desarrollo local documentados; no se describe aquí como código abierto ni como un sandbox de ejecución endurecido.

1. Descripción general de la arquitectura

┌────────────────────────────────────────────────────────┐
│                   AI Coding Agent                      │
│      (Cursor, Claude Code, Claude Desktop, etc.)       │
└───────────────────────────┬────────────────────────────┘
                            │
               JSON-RPC 2.0 │ Stdio Stream
        (stdout pure data / stderr diagnostics)
                            │
┌───────────────────────────▼────────────────────────────┐
│              LocalCloud MCP Bridge (CLI)               │
│          `localcloud mcp` / `McpAdapter`               │
│                                                        │
│  • Auto-starts Docker container on demand if stopped   │
│  • Idempotent data-volume locked startup               │
│  • Guarantees container non-replacement                │
│  • Automatic reconnection on container restart         │
│  • Attributed caller headers (X-LocalCloud-*)          │
└───────────────────────────┬────────────────────────────┘
                            │
            HTTP JSON-RPC │ Local Gateway (port 5380)
                            │ Headers: X-LocalCloud-Project,
                            │          X-LocalCloud-User
┌───────────────────────────▼────────────────────────────┐
│               LocalCloud Docker Runtime                │
│             Volume: `localcloud-data`                  │
│                                                        │
│   GCS • BigQuery • Pub/Sub • Firestore • Spanner       │
│   Cloud SQL • Secret Manager • Cloud Functions • ...   │
└────────────────────────────────────────────────────────┘

Pureza del protocolo Stdio

MCP se comunica mediante JSON-RPC 2.0 a través de la entrada y salida estándar (stdio).

  • stdout: Reservado estrictamente para mensajes JSON-RPC válidos. Cualquier texto de banner, códigos de color o caracteres ASCII en stdout corrompe los analizadores JSON del cliente.
  • stderr: Se usa para diagnósticos de progreso, mensajes de salud del entorno de ejecución y avisos de inicio.
  • Errores: Se traducen en resultados estructurados de herramientas MCP o marcos de error de protocolo JSON-RPC para que el agente de IA pueda leerlos y autocorregirse.

2. Capacidades principales y principios de diseño

Auto-inicio bajo demanda

Cuando un agente de IA lanza localcloud mcp, la CLI verifica si el entorno de ejecución del contenedor está en ejecución:

  • Si está detenido o falta: Inicia automáticamente el contenedor en segundo plano (Controller.start(ensure_project=True, allow_replace=False)).
  • Protección de concurrencia: Toma el bloqueo de archivo por volumen (data_volume_lock) y usa el presupuesto completo de disponibilidad (60s), asegurando que los agentes concurrentes que inician al mismo tiempo no compitan ni agoten el tiempo.
  • Anulación manual: Pasar --no-start deshabilita el auto-inicio, saliendo con el código runtime_not_running si LocalCloud no ya está en ejecución.

Política de no reemplazo

LocalCloud garantiza la estabilidad del contenedor para los agentes en ejecución:

  • Se adjunta al contenedor activo tal como está, incluso si la configuración del host o las opciones de YAML difieren.
  • El reemplazo del contenedor (por ejemplo, cambiar puertos o imágenes) sigue siendo una acción explícita y deliberada usando localcloud start o localcloud restart.

Volumen de datos compartido único y contenedor único

  • Todos los agentes y repositorios comparten el volumen de Docker localcloud-data de forma predeterminada.
  • Múltiples agentes y espacios de trabajo se ejecutan contra una única instancia de contenedor compartida, conservando RAM, CPU y espacio en disco del host.
  • Un --data-volume personalizado solo se usa cuando se exige explícitamente un aislamiento estricto del contenedor.

Alcance a nivel de proyecto lógico

  • El proyecto predeterminado es local-gcp-project, asegurando que todos los comandos (lc env, lc console, lc reset y MCP) se alineen en el mismo proyecto exacto y los datos de muestra sembrados.
  • Cuando un agente o desarrollador pasa un --project-id explícito, el entorno de ejecución asegura que el proyecto lógico exista en la conexión sin reiniciar el contenedor.
  • La identidad del llamador predeterminada es local-developer (normalizada a local-developer@localcloud.invalid), atribuyendo acciones por agente o usuario.

Reconexión automática al reiniciar

  • Después de java_mcp_unavailable, el puente vuelve a resolver la puerta de enlace objetivo. Si la URL de la puerta de enlace cambió, reintenta la solicitud una vez en la nueva URL. Un reinicio que mantiene la misma URL aún puede requerir que el cliente reintente o se reconecte.

3. Configuración con un comando: lc mcp install

LocalCloud proporciona un instalador automatizado que configura asistentes de codificación de IA a nivel de usuario de forma predeterminada para que todos los repositorios puedan acceder a LocalCloud:

# Install for Cursor (user-level in ~/.cursor/mcp.json)
lc mcp install --client cursor

# Install for Claude Code (user scope via `claude mcp add` CLI)
lc mcp install --client claude-code

# Install for Claude Desktop (user-level in claude_desktop_config.json)
lc mcp install --client claude-desktop

# Install for Antigravity (the gemini alias selects Antigravity configuration)
lc mcp install --client gemini

# Install for Windsurf
lc mcp install --client windsurf

# Write the Cursor, Claude Code, Claude Desktop, Antigravity and Windsurf configurations
lc mcp install --client all

En la CLI 0.1.9, all configura los cinco clientes enumerados anteriormente, incluso si sus aplicaciones no están instaladas. Cline y Gemini CLI deben usar las instrucciones de configuración manual a continuación. La ruta --client cline en 0.1.9 no está calificada para la ubicación de configuración de la extensión de VS Code; use el editor de configuración propio de Cline.

Opciones de instalación

IndicadorDescripción
--client <name>Cliente de IA objetivo: cursor (predeterminado), claude-code, claude-desktop, gemini, windsurf, cline o all.
--globalInstalar en la configuración a nivel de usuario (predeterminado: verdadero).
--projectInstalar en la configuración del proyecto/espacio de trabajo en lugar de la configuración a nivel de usuario.
--project-id <id>Fijar un ID de proyecto de GCP específico (predeterminado: local-gcp-project compartido).
--data-volume <name>Especificar un volumen de Docker no predeterminado. (Omitido de forma predeterminada).
--user <name>Especificar la identidad del llamador (predeterminado: local-developer).
--command-path <path>Comando ejecutable o ruta de binario explícito (por ejemplo, /opt/homebrew/bin/lc, localcloud).
--bareUsar el comando localcloud simple en lugar de resolver una ruta absoluta.

Seguridad y atomicidad

  • Sin dependencia de Docker: Ejecutar lc mcp install no requiere que Docker esté en ejecución.
  • Preservación de configuración: Analiza de forma segura los archivos de configuración existentes y preserva los servidores MCP de terceros.
  • Escrituras atómicas: Usa archivos temporales con renombrado atómico (os.replace) para evitar la corrupción de archivos.
  • Resolución de binarios: Para configuraciones a nivel de usuario, prioriza los binarios del sistema instalados globalmente (como Homebrew /opt/homebrew/bin/localcloud, /usr/local/bin/localcloud o PATH del sistema) para que las configuraciones de agentes sean permanentes en todos los proyectos y sobrevivan a la eliminación de virtualenv. Recurre a virtualenv o comando simple si no existe un binario del sistema. Use --bare o --command-path para anulaciones explícitas.

4. Ejemplos de configuración manual

Use command -v localcloud para encontrar el ejecutable instalado. Sustituya esa ruta absoluta en los ejemplos de clientes de escritorio; /opt/homebrew/bin/localcloud es un ejemplo de Homebrew para Apple Silicon, no una ruta universal. Combine la entrada del servidor en la configuración existente en lugar de reemplazar otros servidores.

Codex

codex mcp add localcloud -- "$(command -v localcloud)" mcp
codex mcp list

Alternativamente, combine en ~/.codex/config.toml:

[mcp_servers.localcloud]
command = "/opt/homebrew/bin/localcloud"
args = ["mcp"]
startup_timeout_sec = 120

Consulte Configuración de MCP de Codex para la configuración del cliente.

VS Code / GitHub Copilot

Combine esto en el .vscode/mcp.json del espacio de trabajo, luego use MCP: List Servers en la Paleta de comandos para iniciar localcloud:

{
  "servers": {
    "localcloud": {
      "type": "stdio",
      "command": "/opt/homebrew/bin/localcloud",
      "args": ["mcp"]
    }
  }
}

VS Code usa servers, mientras que Cursor y Claude Desktop usan mcpServers. Consulte Configuración de MCP de VS Code.

Cline

Abre la configuración de MCP Servers de Cline y su editor de configuración. Fusiona la entrada localcloud del ejemplo de Cursor/Claude Desktop que aparece abajo en mcpServers, usando la ruta del ejecutable en tu máquina. Inicia el servidor en Cline y verifica que el descubrimiento de servicios funcione. Esto evita asumir dónde almacena la extensión su configuración. Consulta la documentación de MCP de Cline.

Gemini CLI

El alias --client gemini de la CLI 0.1.9 configura Antigravity. Para configurar Gemini CLI, usa el comando propio de Gemini:

gemini mcp add --scope user localcloud "$(command -v localcloud)" mcp
gemini mcp list

Gemini CLI almacena los servidores MCP en ~/.gemini/settings.json para el ámbito de usuario. Consulta la documentación de MCP de Gemini CLI.

Cursor (~/.cursor/mcp.json o .cursor/mcp.json)

{
  "mcpServers": {
    "localcloud": {
      "command": "/opt/homebrew/bin/localcloud",
      "args": ["mcp"]
    }
  }
}

(En macOS, se recomienda una ruta absoluta como /opt/homebrew/bin/localcloud cuando Cursor se inicia desde el Dock o Finder. Usa "localcloud" sin prefijo si lo lanzas desde una terminal interactiva con PATH configurado).

Claude Code

Ejecuta usando la CLI de Claude Code:

claude mcp add --scope user localcloud -- /opt/homebrew/bin/localcloud mcp

Claude Desktop (claude_desktop_config.json)

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json
  • Linux: ~/.config/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "localcloud": {
      "command": "/opt/homebrew/bin/localcloud",
      "args": ["mcp"]
    }
  }
}

5. Catálogo MCP Autoritativo

El catálogo de solo lectura en tiempo de ejecución verificado para esta guía (versión de runtime MCP 0.1.3) expone 27 herramientas, 14 recursos, 7 plantillas de recursos y 6 prompts. Las versiones de CLI y runtime son independientes. Los catálogos pueden variar según la imagen del runtime y los permisos habilitados: tools/list, resources/list, resources/templates/list y prompts/list del runtime conectado son autoritativos.

Herramientas (27)

  1. Descubrimiento e Invocación de API:
    • localcloud_get_api_catalog: Descubre métodos y esquemas expuestos por el catálogo de API de gestión de LocalCloud.
    • localcloud_call_api: Invoca una operación de gestión local catalogada usando su ID de operación y parámetros tipados.
  2. Inspección de Servicios y Proyectos:
    • localcloud_list_services: Lista todos los servicios GCP en ejecución, su estado y puertos de loopback.
    • localcloud_get_service: Obtén endpoints, puertos y configuración detallados para un servicio específico.
    • localcloud_list_projects: Lista todos los proyectos GCP lógicos inicializados actualmente en el contenedor.
    • localcloud_get_project: Obtén detalles de un proyecto específico.
  3. Navegación de Recursos y Acceso a Datos:
    • localcloud_browse_resources: Navega por buckets, datasets, tablas, topics, suscripciones y colas.
    • localcloud_read_resource: Lee metadatos o contenido de un recurso navegado.
    • localcloud_query_data: Consulta datos en bases de datos emuladas (BigQuery, Spanner, Cloud SQL).
  4. Entorno y Generación de SDK:
    • localcloud_get_env: Obtén variables de entorno de SDK para shell, JSON o Terraform.
    • localcloud_generate_sdk_env: Genera código de exportación de entorno para SDKs de cliente.
    • localcloud_generate_gcloud_env: Genera comandos de configuración de CLI gcloud.
    • localcloud_generate_terraform_env: Genera configuración de proveedor para Terraform / OpenTofu.
    • localcloud_validate_agent_config: Valida que la configuración de SDK del agente coincida con los endpoints de LocalCloud.
  5. Disponibilidad y Compatibilidad:
    • localcloud_check_readiness: Verifica salud y disponibilidad en todos los servicios o en uno específico.
    • localcloud_check_compatibility: Verifica la compatibilidad con la API de Google Cloud y la paridad de funciones soportadas.
  6. Diagnóstico y Registros:
    • localcloud_get_diagnostics: Recupera hallazgos de diagnóstico recientes y eventos de salud.
    • localcloud_get_recent_requests: Inspecciona solicitudes HTTP recientes recibidas por la puerta de enlace de LocalCloud.
    • localcloud_get_logs: Obtén registros del contenedor del runtime y de los emuladores.
  7. Escenarios, Recetas y Estado:
    • localcloud_list_recipes: Lista recetas de escenarios preconfigurados.
    • localcloud_get_recipe: Obtén la definición y acciones de siembra de una receta.
    • localcloud_list_scenarios: Lista escenarios de prueba.
    • localcloud_get_scenario: Obtén la definición de un escenario de prueba.
    • localcloud_get_seed_schema: Inspecciona esquemas de datos de siembra.
    • localcloud_export_state: Exporta el estado del proyecto del runtime.
    • localcloud_list_checkpoints: Lista puntos de control guardados del proyecto.
    • localcloud_diff_project: Compara el estado actual del proyecto contra un punto de control.

Recursos (14)

  • localcloud://api/catalog: Operaciones y esquemas de la API de gestión de LocalCloud.
  • localcloud://api/openapi: Especificaciones OpenAPI para las fachadas de gestión de LocalCloud.
  • localcloud://services: Servicios habilitados y puertos de loopback asignados.
  • localcloud://env/shell: Exportaciones de variables de entorno de shell (export STORAGE_EMULATOR_HOST=...).
  • localcloud://env/json: Representación JSON estructurada de todos los endpoints de emuladores.
  • localcloud://env/terraform: Anulaciones de endpoints del proveedor de Terraform.
  • localcloud://env/databases: Cadenas de conexión de bases de datos (PostgreSQL, MySQL, Redis, Spanner).
  • localcloud://readiness: Informe de disponibilidad en vivo en todos los servicios.
  • localcloud://compatibility: Matrices de compatibilidad de funciones de servicios.
  • localcloud://diagnostics/latest: Diagnósticos más recientes de verificación de salud.
  • localcloud://recipes: Recetas de siembra de datos disponibles.
  • localcloud://scenarios: Escenarios de prueba de integración disponibles.
  • localcloud://terraform/readiness: Verificaciones de disponibilidad del proveedor de Terraform.
  • localcloud://schema/seed: Esquemas de siembra para servicios emulados.

Plantillas de Recursos (7)

  • localcloud://schema/seed/{service}
  • localcloud://readiness/{service}
  • localcloud://compatibility/{service}
  • localcloud://recipes/{id}
  • localcloud://scenarios/{id}
  • localcloud://browse/{service}/{resourceType}
  • localcloud://browse/{service}/{resourceType}/{resourceId}

Prompts (6)

  • use-localcloud-instead-of-gcp: Instruye a los agentes de codificación para dirigir todas las bibliotecas de cliente de Google Cloud, SDKs y configuraciones de Terraform a los emuladores de LocalCloud en lugar de a GCP real.
  • debug-localcloud-service: Orientación para diagnosticar salud y conectividad de servicios.
  • write-localcloud-integration-test: Plantilla y mejores prácticas para escribir pruebas de integración contra LocalCloud.
  • seed-localcloud-scenario: Instrucciones para sembrar fixtures de prueba y datos de prueba.
  • terraform-with-localcloud: Dirigir proveedores de Terraform / OpenTofu a los puertos de loopback de LocalCloud.
  • compatibility-aware-implementation: Diseño de código consciente de la superficie de API emulada de LocalCloud.

6. Mejores Prácticas para Agentes de Codificación

  1. Usa el Prompt MCP integrado: Indica al agente que use el prompt del servidor:

    Sigue el prompt use-localcloud-instead-of-gcp del servidor MCP localcloud. Siempre verifica los endpoints locales usando localcloud_get_env o localcloud://env/shell antes de hacer llamadas a la nube.

  2. Acceso a datos mediante SDKs: Las operaciones de datos (subir archivos a GCS, publicar mensajes en Pub/Sub, consultar Firestore) deben ejecutarse usando bibliotecas de cliente estándar de Google Cloud (google-cloud-storage, @google-cloud/pubsub, etc.) dirigidas a los endpoints de emulador exportados por localcloud_get_env o eval "$(lc env)".

  3. Eficiencia de contenedor único: Debido a que LocalCloud usa un volumen de datos compartido y un contenedor único, múltiples agentes ejecutándose en diferentes repositorios pueden trabajar concurrentemente sin iniciar contenedores duplicados ni desperdiciar RAM del host.

Solución de Problemas

SíntomaAcción
mcp install no se reconoceActualiza LocalCloud a través de su canal de instalación y asegúrate de que el cliente use ese ejecutable
Docker no se puede alcanzarEjecuta lc doctor, inicia Docker y reintenta; instalar la configuración del cliente no requiere Docker
El cliente de escritorio no encuentra localcloudEstablece una ruta de ejecutable absoluta desde command -v localcloud; reinicia el cliente
La primera conexión agota el tiempo de esperaEjecuta lc start --local-only una vez para completar la descarga de la imagen y el inicio, luego reconecta; aumenta el tiempo de espera de inicio del cliente si es necesario
El bridge reporta mcp_connection_timeoutVerifica lc status y lc logs --tail 100; reintenta con localcloud mcp --connect-timeout 60
El runtime está detenido y --no-start está configuradoInícialo explícitamente con lc start, o elimina --no-start para permitir el inicio automático
Una operación de escritura es rechazadaInspecciona la seguridad de la operación y la configuración de permisos del runtime; la instalación del cliente no habilita permisos de escritura/destructivos
Faltan herramientas o un servicio está deshabilitadoInspecciona el catálogo del runtime conectado, la disponibilidad y la compatibilidad; la versión de CLI por sí sola no determina las herramientas del runtime
El analizador de protocolo reporta JSON inválidoAsegúrate de que el cliente inicie localcloud mcp directamente; los wrappers deben mantener los diagnósticos fuera de stdout

Para desconectar, deshabilita o elimina solo la entrada del servidor localcloud en la configuración de MCP del cliente. Esto no elimina el volumen persistente del runtime. Reporta problemas en problemas de LocalCloud CLI con la versión de CLI, imagen/versión del runtime, cliente y salida de error saneada.