Acerca de

Control de versiones basado en grafos semánticos para código escrito por IA. Rastrea entidades y relaciones en lugar de diferencias de archivos, lo que permite el análisis de radio de impacto, la revisión de fusiones en sombra y el contexto de agentes impulsado por MCP para software generado por IA confiable.

<h3 align="center">Una nueva base para el código.</h3>

**Kin es un repositorio de código nativo de grafos para agentes de IA y las personas que construyen con ellos.** Almacena el código fuente, las relaciones de código registradas y el historial versionado como estado del repositorio. El grafo es el modelo del repositorio, no un índice de búsqueda mantenido junto a otro repositorio.

Las funciones, los tipos y las relaciones entre ellos son datos que confirmas, ramificas y fusionas. El código fuente exacto se conserva byte a byte, y las proyecciones del sistema de archivos permiten que las herramientas compatibles sigan funcionando con archivos ordinarios.

**Beta pública.** Prueba Kin en un proyecto real que conozcas bien. Espera asperezas.

[Inicio rápido](#quickstart) · [Documentación](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md) · [Demostración en el navegador](https://kinlab.ai/demo)

Una estrella ayuda a que otras personas encuentren Kin, y [Discussions](https://github.com/kinlab-ai/kin/discussions) es el lugar para plantear una pregunta al respecto.

## Descubre qué está conectado

Antes de cambiar una función compartida, ¿qué más deberías inspeccionar? Kin te permite consultar sus llamadores registrados y explorar el código relacionado. La CLI y el servidor MCP consultan el mismo grafo, para que tú y tu agente podáis trabajar a partir del mismo registro.

*Registrado en un grafo de ripgrep preparado en `e89fff89ac9af12e8d4ce9d5fd07beb408ca730f`. Los artefactos de ejecución sin procesar no son públicos. Esto ilustra un flujo de trabajo, no una prueba de rendimiento.*

## Úsalo desde Claude Code, Codex o Cursor

Para Claude Code:

```
/plugin marketplace add kinlab-ai/kin
/plugin install kin@kin
```

Para [Codex](https://github.com/firelock-ai/kin/blob/main/plugins/kin-codex/README.md#install), añade el marketplace e instala el plugin, o deja que `kin setup --intent agent` escriba el servidor MCP en `~/.codex/config.toml` por ti.

Para Cursor, añade el servidor MCP manualmente; consulta [plugins/kin-cursor](https://github.com/firelock-ai/kin/blob/main/plugins/kin-cursor/README.md#install) para ver el fragmento exacto.

Después de instalar, ejecuta `kin init .` en un clon nuevo de un proyecto que conozcas bien; la skill `kin-setup` te guía por el resto.

Kin no está publicado en crates.io. El crate `kin` que aparece allí es un proyecto no relacionado.

## Inicio rápido

Empieza en un clon nuevo y completo de un proyecto que conozcas bien. `kin init` lee tu historial de Git sin modificarlo ni alterar tus archivos rastreados. Mantiene su almacén fuera de tu checkout, en `~/.kin/stores`, y no escribe nada en el repositorio; `kin store path` muestra dónde está el almacén de un checkout. Por defecto admite primero el commit extraído, de modo que las preguntas se responden en cuanto se lee ese árbol, y luego importa en segundo plano, con baja prioridad, cada commit al que llegan tus ramas y etiquetas; `kin init --history full` importa todo el historial de antemano, y `--history none` nunca lo importa. Importar el historial consume tiempo, memoria y disco que crecen con el historial en lugar de con el tamaño del checkout. Antes de empezar, `kin init` comprueba la memoria y el disco libre y se detiene mostrando las cifras cuando ya puede determinar que a la máquina le falta capacidad. **Un clon superficial solo admite su commit extraído, y los submódulos y Git LFS no son compatibles**, y los hooks de Git, un checkout disperso o una fusión o rebase sin terminar también detienen la importación. `kin init` indica la solución para cada caso, y un clon nuevo evita la mayoría de ellos.

### 1. Instalar

En macOS, Linux y WSL2, un solo comando instala Kin y conecta las herramientas de programación con IA que
encuentra. Requiere Node.js 20 o superior:

```sh
npx -y @kinlab/kin setup
```

En una máquina sin Node, ejecute el instalador en su lugar. `get.kinlab.ai` y `get.kinlab.dev`
sirven el mismo script:

```sh
curl -fsSL https://get.kinlab.dev/install | sh
```

En cualquier caso, recarga tu shell como un comando separado, porque la instalación coloca `kin` en
`~/.kin/bin` y añade ese directorio al perfil de tu shell para nuevas sesiones:

```sh
exec "$SHELL" -l
```

En Windows x64 nativo, instala desde PowerShell con `irm https://get.kinlab.dev/install.ps1 | iex`.
Instala la CLI `kin` y no conecta herramientas de codificación de IA, porque WSL2 sigue siendo
la ruta recomendada en Windows. La entrada de Windows en [Límites de la beta](#beta-limits)
indica qué funciona allí. No se publica ninguna compilación nativa para Windows ARM64. En una máquina ARM64, ejecuta
esa línea desde PowerShell x64 para instalar la compilación x86_64 bajo emulación, o usa WSL2.
El instalador añade `kin` a tu PATH de usuario, así que abre una nueva ventana de PowerShell en lugar de
`exec "$SHELL" -l` antes del siguiente paso.

Para otros instaladores o solución de problemas, consulta la [guía de inicio rápido completa](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md#1-install).

### 2. Inicializa el repositorio

En el nuevo prompt, clona un repositorio con Kin:

```sh
kin clone https://github.com/pallets/itsdangerous
```

O inicializa uno que ya tengas, reemplazando la ruta a continuación:

```sh
cd /path/to/your/repository &&
kin init . &&
kin overview &&
kin status
```

Ambos terminan con el siguiente comando a ejecutar, una pregunta de `kin refs` sobre una función en ese repositorio. También conectan Codex CLI y Grok CLI a él cuando lo permitiste en la configuración, porque esos clientes mantienen una entrada que nombra un repositorio.

Windows PowerShell 5.1 no tiene `&&`, así que en Windows nativo ejecuta los mismos comandos uno a la vez y detente si uno falla:

```powershell
cd C:\path\to\your\repository
kin init .
kin overview
kin status
```

`kin overview` muestra las entidades que Kin importó. `kin status` muestra qué se admitió y el estado del árbol de trabajo respecto a ello. `kin graph status` informa el grafo de consultas en vivo del daemon y su cobertura. Los cambios no confirmados y no rastreados no forman parte del historial de Git importado; `kin init` informa qué dejó fuera.

### 3. Haz una pregunta que puedas verificar

Busca algo que ya sabes que está en el código:

```sh
kin locate "<something you already know is in this repository>"
```

Reemplace `ExactEntityName` a continuación con un símbolo del resultado:

```sh
kin refs ExactEntityName
kin trace ExactEntityName
kin impact ExactEntityName
```

`refs` devuelve las referencias registradas, `trace` incorpora el contexto cercano e `impact` explora los efectos potenciales a través del grafo. Verifica los resultados contra la fuente.

### 4. Tus herramientas de codificación con IA y la búsqueda semántica

`kin setup` ya preguntó antes de conectar las herramientas de codificación con IA que encontró, y las conectó si respondiste que sí. No hay un paso de vinculación por separado. Después de instalar otra herramienta, ejecuta `kin setup` de nuevo, y `kin setup status` muestra qué está conectado. En Windows, conecta las herramientas de IA dentro de WSL2.

`kin runtime status --json` verifica la instalación compartida del CLI y del daemon, incluida su identidad de origen exacta. Los comandos normales rechazan pares que no coinciden; las compilaciones de desarrollo usan un estado aislado. Consulta [instalación del runtime](https://github.com/firelock-ai/kin/blob/main/docs/runtime-installation.md).

La recuperación de grafos y léxica funciona sin un modelo. Los embeddings y el reranking son opcionales, y sus proveedores de modelos por defecto son `none`. Las compilaciones estándar del CLI y del daemon incluyen soporte para modelos HTTP externos. Los modelos integrados requieren una compilación con inferencia local opcional habilitada.

Para construir un índice de embeddings usando un endpoint compatible con OpenAI que tú operes:

```sh
KIN_MODEL_EMBEDDINGS_PROVIDER=external \
KIN_MODEL_EMBEDDINGS_BASE_URL=http://localhost:1234/v1 \
KIN_MODEL_EMBEDDINGS_MODEL=your-served-embedding-model kin embed
```

Los endpoints de modelo reciben el texto de la entidad seleccionada que necesitan para su etapa.
[Configuración del modelo](https://github.com/firelock-ai/kin/blob/main/docs/env-vars.md) describe proveedores, identidades de modelo y nombres de variables de entorno de credenciales.

Kin es compatible con Claude Code, Codex, Cursor, Gemini y otros clientes MCP. Usa `kin setup --intent editor` para VS Code. Kin también incluye `kin agent run` para endpoints de modelo compatibles con OpenAI locales o alojados.

[Configuración del cliente](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#works-with-your-agent) · [Herramientas MCP](https://github.com/firelock-ai/kin/blob/main/docs/mcp-tools.md) · [Agente integrado](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md#kin-agent)

Las importaciones locales, el almacenamiento y las consultas de grafo se ejecutan en tu máquina. Instalar Kin requiere acceso a la red; la ruta de recuperación de grafo predeterminada no necesita descargar ningún modelo. Cuando se selecciona un proveedor de embeddings, las consultas informan su cobertura vectorial y cualquier brecha.

## Revisar un cambio

Después de ejecutar `kin init` en la rama de Git que quieres revisar, compara SHAs de commit explícitos contra `main`:

```sh
kin review shadow "$(git rev-parse main)..$(git rev-parse HEAD)"
```

El informe devuelve `PASS`, `NEEDS ATTENTION` o `WOULD BLOCK`, con el impacto derivado del grafo y la evidencia de respaldo. **Es orientativo:** no bloquea una fusión ni cambia el estado del grafo. La autoría se declara, no se verifica de forma independiente.

## Usar Kin con o sin Git

Kin tiene sus propios commits, ramas, fusiones, diffs e historial, incluso en repositorios sin Git por debajo. Se pueden importar repositorios Git existentes, y los flujos de trabajo compatibles pueden exportar un nuevo repositorio Git.

[Recorrido por el control de versiones nativo](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#version-control-without-git) · [Interoperabilidad con Git y límites de exportación](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#how-kin-relates-to-git)

## Límites de la beta

**La cobertura es incompleta.** Los lenguajes compatibles se analizan en entidades y relaciones; los demás archivos siguen disponibles como contenido e historial. Un resultado vacío no demuestra que no haya llamadores ni dependencias. Sigue usando tu compilador, tus pruebas y la revisión. Consulta [compatibilidad de lenguajes](https://github.com/firelock-ai/kin/blob/main/docs/language-support.md).

**La compatibilidad varía.** Los archivos de publicación no incluyen la proyección de sistema de archivos obsoleta `kin-vfs`, por lo que no hay una proyección transparente en la que confiar. Consulta las [notas de plataforma](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#platform-and-maturity) para saber qué admite cada plataforma.

**Haz copias de seguridad del estado exclusivo de Kin.** Los commits, ramas, revisiones y especificaciones que registras con Kin viven en el almacén de Kin del repositorio, no en Git. Eliminar el almacén y volver a importar desde Git no los recupera, así que ejecuta primero `kin backup create`. `kin store prune` elimina almacenes solo cuando pasas `--yes`, por la misma razón. Lee las [notas de importación, recuperación y actualización](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md#what-is-real-today-and-what-is-beta).

**Windows.** La compatibilidad nativa con Windows x86_64 es incipiente. La admisión de repositorios funciona: `kin init` importa un repositorio Git y publica la autoridad del grafo, y las consultas de grafo, léxicas y respaldadas por el daemon responden de forma nativa. La prueba de instalación de extremo a extremo también ejecuta la configuración del agente en Windows nativo y obtiene respuestas respaldadas por el grafo del servidor MCP instalado. La proyección transparente del sistema de archivos no se distribuye en Windows, y los flujos de trabajo de revisión aún no se han probado allí, por lo que WSL2 sigue siendo la ruta recomendada para la experiencia completa de Kin.

## Por qué construí Kin

Seguía viendo a los agentes de programación recomponer partes de un código base que ya habíamos trabajado. Luego yo hacía una versión de ese trabajo para revisar sus cambios. Empecé a preguntarme por qué más de esa comprensión estructural no formaba parte del propio repositorio.

Eso es lo que estoy construyendo con Kin.

Troy

## Más información y contribución

[Referencia de la CLI](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md) · [Arquitectura y límites detallados](https://github.com/firelock-ai/kin/blob/main/docs/readme-reference.md) · [Contribuir](https://github.com/firelock-ai/kin/blob/main/CONTRIBUTING.md) · [Problemas](https://github.com/kinlab-ai/kin/issues/new/choose) · [Seguridad](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

Kin y su stack local, incluido [kin-db](https://github.com/kinlab-ai/kin-db), están bajo [Apache-2.0](https://github.com/firelock-ai/kin/blob/main/LICENSE). [KinLab](https://kinlab.ai) es el producto alojado propietario independiente. La incorporación al repositorio público aún está en desarrollo.

kin

Más Populares

Acerca de