Lisply-MCP

Un middleware de Node.js que permite a los agentes de IA interactuar con sistemas basados en Lisp utilizando el protocolo Lisply.

GitHub
54
Prueba este MCPPatrocinado

Documentación

[!important] Importante ¿Buscas lisply-mcp? La bifurcación "corporativa" en lenguaje sencillo vive en genworks/lisply-mcp.

Este repositorio (cyborg-whisperer) es el upstream en lenguaje de juegos y se mantiene por separado. Un clon cuyo origin todavía apunta a gornskew/lisply-mcp aterriza aquí; para seguir la bifurcación en su lugar:

git remote set-url origin https://github.com/genworks/lisply-mcp.git

Cyborg Whisperer: un Oficial de Protocolo para Tripulaciones que Hablan Lisp

The Cyborg Whisperer robot, a lambda on its chest

A bordo de una nave clase Basilisk, ningún cyborg deambula. Cada visita — sin importar cómo llegue a bordo — está destinada a un miembro específico de la tripulación, y cada visita comienza de la misma manera: con el Oficial de Protocolo. Él recibe a cada cyborg que llega, lo entrevista, le enseña las costumbres de la nave y lo despacha hacia el miembro de la tripulación que vino a ver.

Cyborg Whisperer es el kit para ese puesto — la especie, por así decirlo, de la cual cada Oficial de Protocolo es miembro. Coloca uno junto a cualquier miembro de la tripulación que responda al dialecto Lisply, a bordo o en tierra, y los cyborgs que lleguen se encontrarán recibidos, educados y puestos a trabajar de manera útil.

En términos simples: este es el middleware que habla MCP — el Protocolo de Reunión y Conducción, en el cual un Oficial reúne a cada cyborg que llega y lo conduce hacia su miembro de la tripulación — con los modelos de lenguaje grandes que son los cyborgs, y un dialecto ligero llamado Lisply con los residentes Lisp que son la tripulación.

Nota: el Oficial no levanta residencia. Es un visitante en una escotilla que ya está abierta — un cliente HTTP puro (HTTP siendo el Protocolo de Transferencia de Escotilla a Escotilla, un saludo simple de una escotilla a otra) hacia un residente que ya está respondiendo. Levantar habitaciones es asunto del vat, a través del astillero Basilisk — ver "Ejecutarlo" en el README de Basilisk — o abre una escotilla Lisply propia en el muelle y apunta al Oficial hacia ella. Una vez que un residente responde, Claude Desktop lo invoca como muestran los registros de ejemplo a continuación.

¿Qué se Supone que Debe Hacer?

El Oficial conecta la nave en la que llega un cyborg — cualquier cliente compatible con MCP, como Claude Desktop — con un residente Lisp que mantiene un REPL, un Bucle de Lectura-Evaluación-Impresión. La conexión está destinada a la programación simbólica asistida por IA, a veces llamada Programación Neuro-Simbólica. Acuñamos "Lisply" para el pequeño dialecto que casi cualquier residente similar a Lisp puede aprender para estar junto a un Oficial de Protocolo propio.

La idea es que el cyborg pueda componer y hacer trabajar invocaciones Lisp arbitrarias, hasta incluir escribir, compilar, cargar y probar pergaminos y proyectos completos.

Modelo de Confianza de Sandbox

Los servidores MCP respaldados por Lisply están destinados a exponerse al LLM como sandboxes de confianza. El envoltorio no está diseñado para restringir operadores Lisp, acceso al sistema de archivos o ejecución de subprocesos dentro del entorno backend. En cambio, se espera que el propio backend se ejecute en un contenedor aislado u otro sandbox elegido por el operador.

Esto es intencional:

  • lisp_eval está destinado a soportar uso libre y completo por parte de los LLM.
  • /projects puede ser un árbol de trabajo montado en el host, pero el resto del sistema de archivos del backend puede permanecer efímero al contenedor.
  • Las decisiones de confianza deben tomarse, por lo tanto, en el límite contenedor/backend, no limitando la evaluación Lisp en el envoltorio MCP.

El envoltorio ahora anuncia este modelo de confianza en los metadatos de las herramientas con un TRUST_AS_SANDBOX=true predeterminado. Los operadores pueden sobrescribir el texto explicativo con SANDBOX_NOTE si es necesario.

Inicio Rápido Extra

Sigue "Ejecutarlo" en el README de Basilisk — git clone el astillero, luego ./basilisk up.

Esto levanta una nave completa, con un Oficial de Protocolo ya en su puesto junto al Capitán.

Inicio Rápido

Lo siguiente te pone en marcha rápidamente con un registro mínimo predeterminado y el residente público predeterminado de Common Lisp (el Primer Oficial, una sala Gendl levantada del vat). Consulta el Contenido principal a continuación para más contexto y todas las banderas.

1. Instalación

  1. Instala Node.js (se recomienda 18+). Si estás en Windows, esto se puede instalar directamente en Windows o en WSL.
  2. Ten un residente con una escotilla abierta para llamar. La forma más fácil es una nave levantada del astillero Basilisk (requiere un vat: Docker); o abre una escotilla Lisply propia en el muelle.
  3. Copia estos pergaminos cyborg-whisperer a algún lugar al que la nave (Claude Desktop, por ejemplo) pueda llegar.

2. Dile a la nave dónde está el Oficial

Edita o crea el registro de la nave como se muestra a continuación. Para Claude Desktop, el registro es típicamente:

/mnt/c/Users/<user>/AppData/Roaming/Claude/claude_desktop_config.json

o

c:\Users\<user>\AppData\Roaming\Claude\claude_desktop_config.json

En el ejemplo a continuación, reemplaza /path/to/cloned/ con la ruta real al pergamino ./scripts/mcp-wrapper.js en tu copia. Los nombres de canal son tuyos para elegir; estos son los propios de las salas, como una nave Basilisk los nombra:

{
  "mcpServers": {
    "gendl-ccl": {
      "command": "node",
      "args": [
        "/path/to/cloned/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "gendl-ccl",
        "--http-port", "9080"
      ]
    },
    "gendl-sbcl": {
      "command": "node",
      "args": [
        "/path/to/cloned/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "gendl-sbcl",
        "--http-port", "9090"
      ]
    },
    "readymax": {
      "command": "node",
      "args": [
        "/path/to/cloned/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "readymax",
        "--http-port", "7080"
      ]
    }
  }
}

O en un escenario WSL (donde Claude Desktop se ejecuta en el host de Windows):

{
  "mcpServers": {
    "gendl-ccl": {
      "command": "wsl",
      "args": [
        "node", "/path/to/cloned/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "gendl-ccl",
        "--http-port", "9080"
      ]
    },
    "gendl-sbcl": {
      "command": "wsl",
      "args": [
        "node", "/path/to/cloned/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "gendl-sbcl",
        "--http-port", "9090"
      ]
    },
    "readymax": {
      "command": "wsl",
      "args": [
        "node", "/path/to/cloned/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "readymax",
        "--http-port", "7080"
      ]
    }
  }
}

Consulta el Contenido principal a continuación para las otras banderas, por ejemplo cómo nombrar la escotilla de un residente en otro lugar. (Guardar bolsas desde el muelle a bordo de una residencia es asunto del astillero — los artículos de Basilisk — no del Oficial.)

Cada canal se sostiene por sí solo, por lo que varios residentes pueden trabajarse a la vez sin que sus herramientas colisionen.

3. Despierta la nave de nuevo y saluda

Con el registro en su lugar, la nave recién despierta tiene un canal llamado bridge, con una herramienta bridge__lisp_eval (entre las pocas otras discutidas en el Contenido principal a continuación). Las herramientas llevan el nombre del canal como prefijo, por lo que varios Oficiales pueden estar de pie a la vez sin colisionar.

Para probarlo, saluda al cyborg:

Evalúa (+ 1 2 3) usando la herramienta bridge__lisp_eval, y házmelo saber el resultado.

El cyborg debería tener la invocación trabajada y responder 6. Prueba invocaciones más complejas antes de continuar.

¿Cómo Funciona la Configuración Mínima Predeterminada?

El registro mínimo del Inicio Rápido llama a un residente Gendl que ya está respondiendo (a bordo de una nave Basilisk, por ejemplo): un superconjunto de Common Lisp con un REPL estándar. El Oficial mismo no levanta nada. Una segunda escotilla Lisply, en Emacs Lisp, la mantiene el Capitán de la sala de preparación Readymax.

Resumen del Sistema

El Oficial es un programa JavaScript que se sostiene en Node.js, un puente entre la nave y cualquier residente que responda al dialecto Lisply. A través de él, un cyborg puede:

  1. entregar al residente una invocación y leer lo que resultó de ella;
  2. saludar cualquier escotilla web que el residente mantenga;
  3. consultar el propio conocimiento del residente — introspección, documentación — mediante invocación;
  4. escribir, compilar, cargar y estudiar pergaminos, nuevamente mediante invocación.

Lisply es el pequeño dialecto: unas pocas escotillas (rutas HTTP), un conjunto estándar de banderas izadas al levantar (variables de entorno) y algunas habilidades opcionales, para que los cyborgs puedan trabajar un residente Lisp vivo.

Arquitectura

El dibujo a continuación muestra aproximadamente quién está dónde:

flowchart TB
    User("the biological") <--> Claude("the craft (Claude Desktop)")
    User <-.-> Emacs("an Emacs of your own (optional)")

    Claude <--> MCP("MCP")
    MCP <--> Wrapper("the Protocol Officer (Cyborg Whisperer, Node.js)")

    Wrapper --> LisplyHttp("the resident's Lisply hatch (HTTP)")
    
    subgraph Backend ["the residence (a room, or a process on the dock)"]
    subgraph LisplyExec["the resident"]
    LisplyHttp
    LisplySwank("the SWANK hatch (for an Emacs of your own)")
    end
    end
    
    Emacs <-.-> LisplySwank
    
    KB[("the chart locker (the corpus)")] <--> Wrapper
    
    LisplyHttp --> Endpoints("web hatches")
    LisplyHttp --> LispEval("incantations")
    
    style User fill:#ff9,stroke:#333,stroke-width:2px
    style Claude fill:#f9f,stroke:#333,stroke-width:2px
    style Emacs fill:#9ff,stroke:#333,stroke-width:2px,stroke-dasharray:5
    style Wrapper fill:#bbf,stroke:#333,stroke-width:2px
    style MCP fill:#bbf,stroke:#333,stroke-width:1px
    style Backend fill:#bfb,stroke:#333,stroke-width:2px
    style LisplyExec fill:#8f8,stroke:#333,stroke-width:2px
    style LisplyHttp fill:#bfb,stroke:#333,stroke-width:1px
    style LisplySwank fill:#bfb,stroke:#333,stroke-width:1px
    style KB fill:#bfb,stroke:#333,stroke-width:1px
    style Endpoints fill:#bfb,stroke:#333,stroke-width:1px
    style LispEval fill:#bfb,stroke:#333,stroke-width:1px

El Oficial:

  1. convierte una llamada de herramienta en MCP en un saludo a la escotilla Lisply del residente, y la respuesta de vuelta en un resultado de herramienta
  2. mantiene el humo (su registro) y reporta lo que salió mal

Consideraciones de Seguridad

Debido a que el Oficial permite que Lisp arbitrario se trabaje en un residente vivo, hay riesgos si el cyborg se "vuelve loco". Mejores prácticas, en términos simples:

  • Deja que el Oficial llame solo a un residente que viva en un contenedor. Dado otro host y puerto, llamará felizmente a cualquier puerto HTTP compatible con Lisply en vivo — no dejes que ese sea un puerto servido por un programa que se ejecute directamente en tu propia máquina.
  • No montes nada que no puedas permitirte perder en ese contenedor (lo que se monta es asunto del astillero — la configuración de compose — no del Oficial).
  • Considera limitar la RAM y la CPU del contenedor.

Los pergaminos en este cofre

  • lib/config.js: Carga de configuración y manejo de entorno
  • lib/logger.js: Funcionalidad de registro
  • lib/server.js: Implementación del servidor HTTP y envoltorio MCP
  • lib/utils.js: Funciones de utilidad para el manejo de respuestas
  • handlers/: Manejadores de solicitudes específicos de herramientas
    • initialize.js: Manejador de inicialización
      • toolsList.js: Manejador de lista de herramientas
      • toolCall.js: Despachador principal de llamadas de herramientas
      • httpRequest.js: Manejador de solicitudes HTTP
      • ping.js: Manejador de ping
      • lispEval.js: Manejador de evaluación Lisp
      • lisply-index.js: el indexador de referencia para un corpus Lisply — el índice lisply_search que un proyecto construye y envía en su propia imagen; el contrato es CORPUS.md
      • lisplySearch.js: Manejador de búsqueda de corpus de documentos, la herramienta lisply_search (backends que la anuncian, por ejemplo, salas Readymax)
  • mcp-wrapper.js: el Oficial mismo — comienza aquí

Publicando al Oficial a mano

  1. Clona este repositorio:
git clone https://github.com/gornskew/cyborg-whisperer.git
  1. Instala lo que necesita para sostenerse (opcional; el Oficial lo obtiene él mismo si falta):
cd cyborg-whisperer/scripts
npm install # optional - the script will attempt to do this also if needed
chmod +x mcp-wrapper.js # needed on some systems
  1. Pídele sus banderas:
node mcp-wrapper.js --help

Las banderas del Oficial

Configuraciones opcionales, con valores predeterminados adecuados para la mayoría de los puestos:

Argumentos de Línea de Comandos

Options:
  -H, --backend-host <host>            Lisply backend host (default: 127.0.0.1)
  --http-host-port <port>              Backend HTTP port as published on this host; used when
                                       backend host is localhost/loopback (default: 9081)
  --http-port <port>                   Backend HTTP port inside the container network; used for
                                       non-local backend hosts (default: 9080)
  --swank-host-port <port>             SWANK port on host system (documentation/diagnostics) (default: 4201)
  --swank-port <port>                  SWANK port inside container (documentation/diagnostics) (default: 4200)
  --log-file <path>                    Path to log file (default: /tmp/lisply-mcp-wrapper.log)
  --debug                              Enable debug logging
  --endpoint-prefix <prefix>           Prefix for all endpoints (default: lisply)
  --lisp-eval-endpoint <n>             Endpoint name for Lisp evaluation (default: lisp-eval)
  --http-request-endpoint <n>          Endpoint name for HTTP requests (default: http-request)
  --ping-endpoint <n>                  Endpoint name for ping (default: ping-lisp)
  --server-name <name>                 MCP server name for tool prefixing (default: lisply-mcp)
  --eval-timeout <ms>                  Timeout for Lisp evaluation in milliseconds (default: 30000)
  --request-timeout-ms <ms>            Timeout for backend HTTP requests in milliseconds (default: 10000)
  -h, --help                           Display help for command

Variables de Entorno

El Oficial también lee banderas izadas al levantar (variables de entorno), con el prefijo "LISPLY_" o sin él:

Nota: mantén clara la diferencia entre una escotilla en el muelle (escuchando en, y alcanzable desde, la máquina host) y una escotilla dentro de la residencia (lo que el residente mismo ve):

Variable de EntornoDescripciónPredeterminado
BACKEND_HOST o LISPLY_BACKEND_HOSTHost backend Lisply127.0.0.1
HTTP_HOST_PORT o LISPLY_HTTP_HOST_PORTPuerto HTTP del backend publicado en este host (backends de bucle local)9081
HTTP_PORT o LISPLY_HTTP_PORTPuerto HTTP del backend dentro de la red del contenedor (backends no locales)9080
SWANK_HOST_PORT o LISPLY_SWANK_HOST_PORTPuerto SWANK en el sistema host (documentación/diagnósticos)4201
SWANK_PORT o LISPLY_SWANK_PORTPuerto SWANK dentro del contenedor (documentación/diagnósticos)4200
LOG_FILE o LISPLY_LOG_FILERuta al archivo de registro/tmp/lisply-mcp-wrapper.log
DEBUG_MODE o LISPLY_DEBUG_MODEHabilitar registro de depuraciónfalse
EVAL_TIMEOUT o LISPLY_EVAL_TIMEOUTTiempo de espera para la evaluación Lisp en ms30000
REQUEST_TIMEOUT_MS o LISPLY_REQUEST_TIMEOUT_MSTiempo de espera para solicitudes HTTP del backend en ms10000
ENDPOINT_PREFIX o LISPLY_ENDPOINT_PREFIXPrefijo para todos los endpointslisply
LISP_EVAL_ENDPOINT o LISPLY_LISP_EVAL_ENDPOINTNombre del endpoint para evaluación Lisplisp-eval
HTTP_REQUEST_ENDPOINT o LISPLY_HTTP_REQUEST_ENDPOINTNombre del endpoint para solicitudes HTTPhttp-request
PING_ENDPOINT o LISPLY_PING_ENDPOINTNombre del endpoint para pingping-lisp
SERVER_NAME o LISPLY_SERVER_NAMENombre del servidor MCP para prefijo de herramientaslisply-mcp
TRUST_AS_SANDBOX o LISPLY_TRUST_AS_SANDBOXAnunciar el backend como un sandbox explícitamente confiable en los metadatos de herramientastrue
SANDBOX_NOTE o LISPLY_SANDBOX_NOTESobrescribir el texto de la nota de sandbox mostrado en los metadatos de herramientas(nota incorporada)

Levantar habitaciones es asunto del vat, no del Oficial

Los Oficiales anteriores podían tirar, levantar y cuidar residencias ellos mismos (eligiendo el reparto, guardando bolsas, levantando bajo demanda, sintiendo una sala ya activa). Todo ese subsistema está en el ático. El Oficial ahora es un visitante puro: saluda a cualquier residente que ya responda en el host y la escotilla que se le dieron, y lo dice de manera útil (con una pista para levantar la nave) cuando no hay nadie en casa.

Para salas levantadas del vat (Gendl, Readymax y el resto), usa el astillero Basilisk, github.com/gornskew/basilisk (./basilisk up), cuyos artículos eligen los repartos, guardan las bolsas, abren las escotillas en el muelle y mapean los uids. Para un residente que vive en el muelle, abre la escotilla tú mismo (la ruta del traje espacial en readymax docs/HOST_EMACS_MCP.md, por ejemplo) y apunta al Oficial hacia él.

Comunicación

Hay dos enlaces involucrados, y son fáciles de confundir:

  1. craft ↔ Officer: MCP sobre entrada/salida estándar (el transporte estándar MCP stdio). El cableado JSON-RPC que el craft gestiona, no tiene nada que ver con el REPL de ningún residente.
  2. Officer ↔ residente: Solo HTTP. El Officer hace POST en las escotillas de Lisply del residente y devuelve respuestas estructuradas.

Cómo es el enlace de escotilla:

  • Respuestas estructuradas con campos separados para resultado, stdout y error
  • Los errores son capturados por el backend y devueltos como cadenas
  • Formato de respuesta: {Result: <result>, Stdout: <output>, Error: <any error>}

Ejemplo de respuesta:

{"Result": "6", "Stdout": "This is a message to standard output"}

Un "modo stdio" anterior, que hablaba con el REPL crudo de una residencia que el Officer había levantado él mismo (el depurador interactivo, salida tal como llegaba), fue al desván con el levantamiento. Lo similar puede volver en la escotilla (una escotilla de reinicios, salida en streaming) sin atar al Officer al tanque de nuevo.

Ejemplos de uso

Todos los ejemplos siguientes pueden probarse en una shell y usarse en el registro claude_desktop_config.json (ver el Inicio Rápido arriba).

Un segundo canal junto al Officer: un servidor de sistema de archivos

A continuación hay un claude_desktop_config.json que publica un servidor MCP de sistema de archivos junto a nuestro Officer lisply-gendl. (El servidor de sistema de archivos toma su bolsa aquí; las bolsas guardadas a bordo de una residencia son artículos del astillero, no del Officer.)

{
  "mcpServers": {
    "filesystem": {
      "command": "wsl",
      "args": [
        "docker",
        "run",
        "-i",
        "--rm",
        "-u",
        "1000:1000",
        "--mount",
        "type=bind,src=/home/user/projects,dst=/projects",
        "mcp/filesystem",
        "/projects"
      ]
    },
    "lisply-gendl": {
      "command": "wsl",
      "args": [
        "node",
        "/home/user/projects/cyborg-whisperer/scripts/mcp-wrapper.js",
        "--server-name", "gendl"
      ]
    }
  },
  "globalShortcut": ""
}

Las herramientas que concede, en detalle

El encantamiento (<channel>__lisp_eval)

La herramienta lisp_eval (prefijada con el nombre del canal, p. ej. gendl__lisp_eval) permite que un cíborg entregue al residente un encantamiento para trabajar, con estos parámetros:

  • code (obligatorio): El código Lisp a evaluar
  • package (opcional): El paquete a usar para la evaluación

El saludo (<channel>__http_request)

La herramienta http_request (prefijada con el nombre del canal, p. ej. gendl__http_request) permite que un cíborg alcance cualquier escotilla web que el residente mantenga (este ejemplo funciona contra el residente Gendl predeterminado, cuya escotilla /color-map está integrada):

{
  "path": "/color-map",
  "method": "GET",
  "headers": {
    "Accept": "application/json"
  }
}

¿Hay alguien en casa? (<channel>__ping_lisp)

La herramienta ping_lisp (prefijada con el nombre del canal, p. ej. gendl__ping_lisp) permite que un cíborg confirme que el residente responde:

<server>__ping_lisp()

Un primer encantamiento, trabajado

Ejemplo 1: una caja paramétrica

Aquí un cíborg (Claude) hace que el residente construya una caja paramétrica, y luego la cambia según pide el biológico.

Usuario: "¿Puedes crear una caja con ancho 10, alto 5 y profundidad 3? Luego muéstrame cómo cambiar el alto a 8."

Claude:

Crearé una caja paramétrica usando la herramienta lisp_eval, y luego te mostraré cómo modificar su alto.

Primero, creemos la caja con las dimensiones especificadas:

(in-package :gdl-user)

;; First, create a box with the specified dimensions
(defparameter *my-box* (make-object 'box 
                         :width 10 
                         :height 5 
                         :length 3))

;; Let's verify the dimensions
(list (theo *my-box* width)
      (theo *my-box* height)
      (theo *my-box* length))

Ahora, cambiemos el alto de 5 a 8:

;; Change the height using setf with accessor
(theo *my-box* (set-slot! :height 8))

;; Alternatively, we could create a new box
(defparameter *new-box* (make-object 'box 
                         :width 10 
                         :height 8  ;; Updated height
                         :length 3))

;; Verify the new dimensions of original box
(list (theo *my-box* width)
      (theo *my-box* height)
      (theo *my-box* length))

Esta caja puede visualizarse creando una interfaz web o usando una herramienta de visualización gendl integrada como geysr. Ver Documentación de Gendl para detalles.

Solución de problemas

Problemas comunes y soluciones

Nadie en casa

Si el Officer informa que no puede alcanzar al residente:

  1. A bordo del barco, asegúrate de que el barco esté levantado:
cd ~/projects/basilisk && ./basilisk up
  1. Saluda a la escotilla tú mismo:
curl http://localhost:9081/lisply/ping-lisp

El craft no puede comunicarse

Si el craft no puede alcanzar al residente al que fue apuntado:

  1. ¿Está el barco levantado (a bordo del barco)?
docker ps    # every room listed, and healthy
  1. Lee el humo del Officer:
tail -f /tmp/lisply-mcp-wrapper.log
  1. Lee el humo del propio craft (el registro de Claude Desktop) con herramientas de Windows, p. ej. Bloc de notas. Típicamente en:

WSL/Linux:

/mnt/c/Users/<user>/AppData/Roaming/Claude/logs/mcp-server-lisply.log

Windows:

c:\Users\<user>\AppData\Roaming\Claude\logs\mcp-server-lisply.log
  1. Saluda a la escotilla tú mismo:
curl http://localhost:9081/lisply/ping-lisp
  1. Prueba la escotilla SWANK (4201 en el muelle por defecto):
M-x slime-connect  ;; from emacs

Un Capitán que use los pergaminos Readymax ya conoce M-x slime-connect.

Sorpresas de permisos

Si encuentras sorpresas de propiedad de archivos en una bolsa guardada a bordo de una residencia, recuerda que el almacenamiento y el mapeo de uid son artículos del astillero, no del Officer. Verifica los permisos de la bolsa:

ls -l /path/to/mounted/directory

Leyendo el humo

Dónde mirar, en orden:

  1. El humo del Officer:
tail -f /tmp/lisply-mcp-wrapper.log
  1. El humo del barco (a bordo del barco):
cd ~/projects/basilisk && ./basilisk logs
  1. La escotilla:
curl http://localhost:9081/lisply/ping-lisp
  1. El tanque:
docker system info

Licencia

Este software está licenciado bajo la GNU Affero General Public License v3.0 (AGPL-3.0), la misma licencia que usa Gendl.

Implicaciones de la licencia

Simplemente usar este servidor MCP para interactuar con un backend de Lisply y obtener salidas no activa los requisitos de la AGPL, p. ej. puedes usar este envoltorio para interactuar con Gendl sin estar obligado a compartir tu código.

Sin embargo, si modificas o extiendes este envoltorio, o un backend de Lisply compatible con la licencia como Gendl, y deseas distribuir y/o alojar un servicio basado en ese resultado (comercial o no), entonces la AGPL requeriría que compartas tus modificaciones con los destinatarios o usuarios posteriores.

Para aplicaciones que necesitan mantener su código fuente cerrado, Genworks ha comenzado a ofrecer una "cláusula de escape" de las restricciones de la AGPL por una regalía trimestral auto-reportada del 5% de los ingresos. Más información y una pasarela de pago están disponibles en genworks.com/royalties.