Conduit

Il control plane on-prem per agenti di codifica AI. Attribuzione dei costi per ingegnere · budget rigidi · governance dell'egresso · osservabilità del context-rot · esportazioni pronte per audit — tutto all'interno della tua VPC.

Conduit si posiziona tra i tuoi agenti di codifica AI (Claude Code, Cursor, Codex, Aider) e qualsiasi provider tu stia già utilizzando (Anthropic, OpenAI, Bedrock, Azure — o la tua implementazione LiteLLM / Portkey esistente). Una sola variabile d'ambiente da adottare, zero modifiche al client, prompt e completamenti mai memorizzati.

[Claude Code / Cursor / Codex]
         │  ANTHROPIC_BASE_URL=https://conduit.yourco.dev
         ▼
[Conduit]  vk_live_… (per-engineer)
         │  metering · budgets · governance · audit · context-rot
         ▼
[LiteLLM / Portkey / direct providers]
         │
         ▼
[Anthropic / OpenAI / Bedrock / Azure]

Screenshot

Panoramica — spesa, risparmi dalla cache, token, richieste bloccate e flag di governance a colpo d'occhio.

Applicazione del budget rigido — superato il limite, viene restituito un 402 al gateway, prima che la richiesta raggiunga il provider.

Governance dell'egresso — una richiesta che trasporta una chiave AWS viene bloccata con un 451; viene registrata solo la categoria, mai il valore.

Attività — ogni richiesta con uno stato distinto: successo · cache hit · limitato dalla velocità · modello bloccato · budget superato · governance bloccata.

Impostazioni — CRUD completo per organizzazione, credenziali del provider, team, budget e chiavi virtuali.

Perché

Gli endpoint privati di Bedrock / Vertex / Azure e i BAA senza training risolvono il canale verso il fornitore. Non dicono alla finanza chi ha speso i $40k, non intercettano i segreti in uscita, non forniscono una registrazione per gli auditor e non mostrano dove il context-rot sta consumando il tuo budget di token. Questa è la lacuna che Conduit colma — senza mai vedere i tuoi prompt.

Cosa ottieni

• Attribuzione dei costi per ingegnere/ per chiave/ per modello — la ripartizione che una chiave API condivisa non può produrre strutturalmente.
• Budget rigidi + liste di modelli consentiti — 402 a chiusura per superamento, 403 chiaro per modello non consentito (mai un downgrade silenzioso).
• Governance dell'egresso — scansione dei segreti T1 (chiavi API / token / chiavi private) + lista di entità consentite T2-lite per organizzazione (i nomi dei tuoi clienti, nomi in codice, codici contratto). Avviso → promuovi a blocco una categoria alla volta. Registra la categoria, mai il valore.
• Pannello context-rot — raggruppa le richieste per dimensione dei token di input e mostra la curva costo-e-tasso-di-errore. Conduit misura; non modifichiamo mai il prompt (questo romperebbe la cache dei prefissi di Anthropic).
• Esportazione pronta per auditor — ogni richiesta come riga CSV/JSON con soli metadati.
• Chiavi virtuali — gli ingegneri possiedono chiavi sostitutive revocabili; la credenziale reale del provider è sigillata con AES-256-GCM nel gateway e non tocca mai un laptop.

Avvio rapido

Opzione A — esegui la release firmata (nessuna compilazione, ~30 secondi)

Recupera le ultime immagini firmate da GHCR (verificabili tramite cosign verify, vedere Postura di sicurezza).

# 1. Ottieni il file compose + il template .env (nessuna clonazione completa necessaria)
curl -fsSL https://raw.githubusercontent.com/anee769/conduit/master/docker-compose.yml -o docker-compose.yml
curl -fsSL https://raw.githubusercontent.com/anee769/conduit/master/.env.example -o .env

# 2. Genera una vera chiave di crittografia master
sed -i.bak "s|^MASTER_ENCRYPTION_KEY=.*|MASTER_ENCRYPTION_KEY=$(openssl rand -base64 32)|" .env && rm .env.bak

# 3. Recupera le immagini firmate + avvia
docker compose --profile app pull
docker compose --profile app up -d

# 4. Esegui le migrazioni + carica il libro dei prezzi (una tantum)
docker exec conduit-gateway-1 pnpm --filter @finops/db db:migrate
docker exec conduit-gateway-1 pnpm --filter @finops/db seed-pricing

# → apri http://localhost:3000/setup → crea org / credenziale / team / chiave virtuale

Fissare una release specifica esportando GATEWAY_IMAGE e CONTROL_PLANE_IMAGE prima di up:

export GATEWAY_IMAGE=ghcr.io/anee769/conduit-gateway:v0.1.0
export CONTROL_PLANE_IMAGE=ghcr.io/anee769/conduit-control-plane:v0.1.0

Opzione B — compila dal sorgente (~2 minuti, per hacking)

git clone https://github.com/anee769/conduit && cd conduit
cp .env.example .env
sed -i.bak "s|^MASTER_ENCRYPTION_KEY=.*|MASTER_ENCRYPTION_KEY=$(openssl rand -base64 32)|" .env && rm .env.bak

docker compose --profile app up -d --build
docker exec conduit-gateway-1 pnpm --filter @finops/db db:migrate
docker exec conduit-gateway-1 pnpm --filter @finops/db seed-pricing

Punta qualsiasi strumento AI verso di esso

export ANTHROPIC_BASE_URL=http://localhost:4000
export ANTHROPIC_AUTH_TOKEN=vk_live_…       # chiave virtuale da /setup
claude                                       # oppure cursor / codex / aider

Guida completa da zero in INSTALL.md.

Funziona con ciò che già utilizzi

Come si confronta Conduit

LiteLLM è eccellente per alias e routing dei modelli — Conduit aggiunge il livello richiesto dai tuoi team di sicurezza e finanza. Portkey è la sovrapposizione di funzionalità più vicina, ma è enterprise closed-source una volta che hai bisogno di governance + on-prem. Helicone è solo osservabilità (ti dice dove sono finiti i token; non controlla dove vanno).

Onesto su ciò che NON è qui

• Nessuna certificazione SOC 2 / HIPAA / ISO ancora. Non rivendicheremo una certificazione che non abbiamo. Progettiamo Conduit per supportare il vostro audit e fornire gli artefatti (SBOM, immagini firmate, white paper sulla sicurezza, CAIQ-lite). Vedi SECURITY.md per la postura completa.
• Nessun SSO / SAML / RBAC ancora — oggi token admin + password del dashboard. In roadmap quando un acquirente lo richiede.
• Bedrock streaming non è completato (framing binario AWS event-stream). Bedrock non-streaming /invoke funziona.
• L'adattatore Google Vertex non è stato costruito.
• Governance T2 completa basata su ML (inferenza del tipo di entità) non è stata costruita — solo la versione leggera (lista di entità consentite incollate dall'operatore). Costruita contro il traffico reale di un partner, non prima.

Postura di sicurezza

Conduit viene eseguito interamente nel tuo cloud — nessun fornitore nel percorso della richiesta, nessun phone-home, air-gappable. Vedi SECURITY.md per il white paper (diagramma del flusso dati, cosa viene memorizzato, crittografia, autenticazione a chiusura, postura di conformità, modello delle minacce).

• Le immagini dei container sono firmate tramite Sigstore cosign (OIDC senza chiave) e sono fornite con un'attestazione CycloneDX SBOM. Rilasciate su ghcr.io/anee769/conduit-gateway e ghcr.io/anee769/conduit-control-plane ad ogni tag git v* (vedi .github/workflows/release.yml). Verifica qualsiasi tag rilasciato:
  root@kitploit:~

  cosign verify ghcr.io/anee769/conduit-gateway:<tag> \
    --certificate-identity-regexp 'https://github.com/anee769/conduit' \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com
  

• Genera un SBOM localmente in qualsiasi momento con bash scripts/sbom.sh.
• 86 test automatizzati vengono eseguiti su ogni PR — inclusi il vettore di riferimento AWS SigV4 e un invariante di privacy della governance (il valore del segreto/entità non appare mai negli eventi memorizzati).

Architettura (brevemente)

• apps/gateway — Hono su Node, il data plane a caldo. Nessun passaggio di build (tsx). Client ClickHouse a zero dipendenze + ioredis.
• apps/control-plane — Dashboard Next.js 15 / React 19 + API admin + procedura guidata /setup al primo avvio.
• packages/db — Schema Drizzle, crittografia AES-256-GCM, hashing delle chiavi, prezzi + budget.
• Archivi: Postgres (configurazione / identità / budget / prezzi) + ClickHouse (usage_events solo append) + Redis (cache + limiti di velocità + contatori di budget in tempo reale).

Ciclo di vita della richiesta (apps/gateway/src/routes/proxy.ts):

auth (vk) → rate limit → model allow-list → budget check
         → governance scan (T1 secrets + T2-lite entities)
         → cache lookup → resolve credential → adapter.prepare()
         → forward + tee stream (client untouched; meter branch in background)

Test

bash scripts/run-tests.sh             # full unit + live-system suite (72 tests)
bash scripts/run-tests.sh --unit-only # pure logic, no Docker stack needed
pwsh scripts/run-tests.ps1            # Windows equivalent

La CI (.github/workflows/ci.yml) esegue entrambi i job su ogni PR — unisci solo quando è verde.

Contribuire

PR benvenuti. Percorso rapido:

git checkout -b feat/my-change
# …
bash scripts/ci-local.sh              # runs the same checks CI runs
bash scripts/ci-local.sh --fast       # typecheck + unit only, no Docker
git push -u origin feat/my-change
gh pr create --base dev

Flusso dei branch: feature → dev → master. La CI deve passare prima dell'unione.

Licenza

Licenza Apache 2.0 — stessa licenza di Kubernetes, Terraform, Kafka. Usala commercialmente, modificala, rivendila; per favore non pretendere che Conduit sia opera tua.

Link

• Sito: getconduit.vercel.app
• Postura di sicurezza: SECURITY.md
• Esecuzione con LiteLLM: docs/run-with-litellm.md
• Guida all'installazione: INSTALL.md