NocturnusAI

Licencia en una línea. Business Source License 1.1 (SPDX: BUSL-1.1). Gratuita para uso interno —incluyendo producción interna— dentro de tu propia organización. Ofrecer NocturnusAI o una funcionalidad sustancial como producto/servicio alojado a terceros requiere una licencia comercial (licensing@nocturnus.ai). Se convertirá a Apache 2.0 el 19-02-2030.

Entran grandes matrices de turnos. Salen ventanas de contexto optimizadas.

Si tu agente sigue reintroduciendo el historial de chat, la salida de herramientas, notas de CRM, reintentos y resúmenes obsoletos en cada llamada al modelo, NocturnusAI reduce eso primero.

El flujo de trabajo principal no es "aprender predicados". Es:

1. Enviar los turnos sin procesar que ya tienes.

2. Obtener un conjunto de trabajo más pequeño.

3. Acotar ese conjunto para la siguiente pregunta.

4. Reutilizar diferencias (diffs) para que los turnos posteriores solo envíen lo que ha cambiado.

Los predicados, reglas, inferencia, mantenimiento de la verdad, ámbitos y lógica temporal siguen ahí. Son importantes. Simplemente pertenecen detrás de la historia principal, no delante de ella.

El bucle de trabajo

Se requiere un LLM para turnos en lenguaje natural. Los ejemplos a continuación envían turnos de texto sin procesar a través de un LLM para extraer hechos estructurados. Si inicias el servidor sin un proveedor de LLM, los turnos en lenguaje natural devolverán cero hechos. Consulta Inicio rápido para ver las opciones de configuración, o utiliza la sintaxis de predicados (p. ej., "customer_tier(acme_corp, enterprise)") que funciona sin ningún LLM.

1. Primera reducción: POST /context

curl -X POST http://localhost:9300/context \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{
    "turns": [
      "user: Customer says they are enterprise and blocked on SLA credits.",
      "tool: CRM says account is Acme Corp with a 2M ARR contract.",
      "agent: Last week support promised to review SLA eligibility.",
      "tool: Billing note says renewal is due next month."
    ],
    "maxFacts": 12
  }'

Forma de la respuesta (los hechos y los valores de relevancia dependen de la extracción del LLM):

{
  "facts": [
    {"predicate":"customer_tier","args":["acme_corp","enterprise"],"salience":0.65},
    {"predicate":"contract_value","args":["acme_corp","2000000"],"salience":0.65},
    {"predicate":"issue","args":["acme_corp","sla_credits"],"salience":0.64}
  ],
  "totalFactsInKB": 7,
  "factsReturned": 3,
  "contradictions": 0,
  "newFactsExtracted": 3
}

2. Pase basado en objetivos: POST /memory/context

curl -X POST http://localhost:9300/memory/context \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{
    "goals": [
      {"predicate":"eligible_for_sla","args":["acme_corp"]}
    ],
    "maxFacts": 12,
    "sessionId": "ticket-42"
  }'

Utiliza esto cuando sepas qué es lo que la siguiente llamada al modelo intenta responder.

3. Turnos posteriores: POST /context/diff

curl -X POST http://localhost:9300/context/diff \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{
    "sessionId": "ticket-42",
    "maxFacts": 12
  }'

Esto devuelve solo las entradas added (añadidas) y removed (eliminadas) entre instantáneas.

4. Fin del hilo: POST /context/session/clear

curl -X POST http://localhost:9300/context/session/clear \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{"sessionId":"ticket-42"}'

Elige tu interfaz

SDK de Python

from nocturnusai import SyncNocturnusAIClient

with SyncNocturnusAIClient("http://localhost:9300") as client:
    ctx = client.process_turns(
        turns=[
            "user: Customer says they are enterprise and blocked on SLA credits.",
            "tool: CRM says account is Acme Corp with a 2M ARR contract.",
        ],
        scope="ticket-42",
        session_id="ticket-42",
    )

    diff = client.diff_context(session_id="ticket-42", max_facts=12)
    client.clear_context_session("ticket-42")

    print(ctx.briefing_delta)

SDK de TypeScript

import { NocturnusAIClient } from 'nocturnusai-sdk';

const client = new NocturnusAIClient({
  baseUrl: 'http://localhost:9300',
  tenantId: 'default',
});

const ctx = await client.processTurns({
  turns: [
    'user: Customer says they are enterprise and blocked on SLA credits.',
    'tool: CRM says account is Acme Corp with a 2M ARR contract.',
  ],
  scope: 'ticket-42',
  sessionId: 'ticket-42',
});

const diff = await client.diffContext({
  sessionId: 'ticket-42',
  maxFacts: 12,
});

await client.clearContextSession('ticket-42');
console.log(ctx.briefingDelta);

MCP

Añade Nocturnus como servidor MCP:

{
  "mcpServers": {
    "nocturnus": {
      "url": "http://localhost:9300/mcp/sse",
      "transport": "sse"
    }
  }
}

Utiliza la herramienta context en cada turno para obtener un conjunto de trabajo clasificado por relevancia. Combina MCP con los puntos finales de contexto HTTP cuando necesites un ensamblaje y diferencias basados en objetivos.

Lo que hay detrás del flujo de trabajo

Cuando necesitas mecanismos de backend, NocturnusAI los proporciona:

• Almacenamiento determinista de hechos y reglas

• Inferencia de encadenamiento hacia atrás con cadenas de prueba

• Mantenimiento de la verdad y manejo de contradicciones

• Hechos temporales con ttl, validFrom y validUntil

• Multi-tenencia mediante X-Database y X-Tenant-ID

• Interfaces MCP, REST, SDK de Python, SDK de TypeScript y CLI sobre el mismo motor

Ese es el backend. La historia de cara al producto sigue siendo la reducción de turnos.

Inicio rápido

Docker (más rápido)

docker run -d --name nocturnusai -p 9300:9300 \
  --restart unless-stopped \
  -v nocturnusai-data:/data \
  ghcr.io/auctalis/nocturnusai:latest

Verifica que se está ejecutando:

curl http://localhost:9300/health

Prueba el motor de lógica (funciona inmediatamente, no se necesita LLM):

curl -X POST http://localhost:9300/tell \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{"predicate":"customer_tier","args":["acme_corp","enterprise"]}'

curl -X POST http://localhost:9300/tell \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{"predicate":"contract_value","args":["acme_corp","2000000"]}'

curl -X POST http://localhost:9300/ask \
  -H 'Content-Type: application/json' \
  -H 'X-Tenant-ID: default' \
  -d '{"predicate":"customer_tier","args":["acme_corp","?tier"]}'

Eso es todo. El servidor se está ejecutando, persiste los datos en un volumen de Docker con nombre y se reinicia automáticamente. Para la extracción de turnos en lenguaje natural (el bucle de trabajo anterior), añade un proveedor de LLM; consulta la siguiente sección.

Docker con Ollama (habilita la extracción en lenguaje natural)

Si tienes Ollama ejecutándose localmente:

docker run -d --name nocturnusai -p 9300:9300 \
  --add-host=host.docker.internal:host-gateway \
  -e LLM_PROVIDER=ollama \
  -e LLM_MODEL=granite3.3:8b \
  -e LLM_BASE_URL=http://host.docker.internal:11434/v1 \
  -e EXTRACTION_ENABLED=true \
  ghcr.io/auctalis/nocturnusai:latest

Script de instalación (CLI + asistente de configuración)

curl -fsSL https://raw.githubusercontent.com/Auctalis/nocturnusai/main/install.sh | bash

Descarga el binario de la CLI e inicia un asistente de configuración interactivo donde eliges tu proveedor de LLM (Ollama, Anthropic, OpenAI, Google o saltar). Crea una instalación persistente de Docker Compose.

Atajos si ya sabes lo que quieres:

curl -fsSL ... | bash -s -- --host-ollama    # Reuse local Ollama
curl -fsSL ... | bash -s -- --ollama         # Bundle Ollama in Docker
curl -fsSL ... | bash -s -- --key sk-ant-... # Use Anthropic

SDK de Python

pip install nocturnusai

SDK de TypeScript

npm install nocturnusai-sdk

Cliente MCP

Copia una de las configuraciones de mcp-configs/.

Desde este repositorio (colaboradores)

make up-ollama
make smoke

CLI

La CLI es útil para la inspección interactiva y la recuperación de ventanas de relevancia:

nocturnusai                                # Interactive REPL
nocturnusai -e "context 10"               # Salience-ranked working set
nocturnusai -e "compress"                 # Simplified alias: POST /memory/compress
nocturnusai -e "cleanup 0.05"             # Simplified alias: POST /memory/cleanup

Para ventanas de contexto y diferencias basadas en objetivos, utiliza la API REST o los SDK junto con la CLI.

Documentación

Documentación completa: nocturnus.ai

Docker Compose (avanzado)

Para configuración persistente, monitorización o empaquetado con Ollama:

git clone https://github.com/Auctalis/nocturnusai.git && cd nocturnusai

make up                                        # Server using .env.example defaults
make up-ollama                                 # + Ollama (reuses host or starts bundled)
make up-monitoring                             # + Prometheus + Grafana
make smoke                                     # Verify health + context endpoint

Construir desde el código fuente

Requiere JDK 17+.

./gradlew :nocturnusai-server:run              # HTTP server on :9300
./gradlew :nocturnusai-cli:run                 # Interactive REPL (JVM)
./gradlew :nocturnusai-cli:nativeCompile       # Build native binary
./gradlew test                                 # Full test suite

Contribuir

Consulta CONTRIBUTING.md. Los problemas etiquetados como good first issue son buenos puntos de entrada.

Seguridad

Informa de vulnerabilidades de forma privada a través de GitHub Security Advisories. Consulta SECURITY.md.

Licencia

Business Source License 1.1 - gratuita para uso no comercial y uso interno en producción dentro de tu organización. Ofrecer NocturnusAI a terceros como producto o servicio requiere una licencia comercial de licensing@nocturnus.ai. Se convertirá a Apache 2.0 el 19-02-2030. Consulta LICENSE y DISCLAIMER.md.

AVISO LEGAL Y DE SEGURIDAD

NocturnusAI es un motor de razonamiento determinista, pero su salida es tan fiable como los hechos que se le proporcionan.

1. Sin garantía de veracidad. "Verificado" se refiere a la consistencia lógica de la inferencia, no a la precisión de las afirmaciones del mundo real.

2. No apto para decisiones autónomas de alto riesgo. No utilices este motor para decisiones médicas, financieras, legales o de seguridad física sin supervisión sin un paso de verificación humana independiente.

3. Solo capa de lógica. NocturnusAI proporciona información e inferencia; no ejecuta acciones.

4. Sin responsabilidad. Consulta DISCLAIMER.md y LICENSE.