Conduit

O plano de controle on-prem para agentes de codificação de IA. Atribuição de custo por engenheiro · orçamentos rígidos · governança de egresso · observabilidade de rotação de contexto · exportações prontas para auditoria — tudo dentro da sua VPC.

O Conduit fica entre seus agentes de codificação de IA (Claude Code, Cursor, Codex, Aider) e qualquer provedor que você já usa (Anthropic, OpenAI, Bedrock, Azure — ou sua implantação LiteLLM / Portkey existente). Uma variável de env para adotar, zero mudanças no cliente, prompts e completações nunca armazenados.

[Claude Code / Cursor / Codex]
         │  ANTHROPIC_BASE_URL=https://conduit.yourco.dev
         ▼
[Conduit]  vk_live_… (por engenheiro)
         │  medição · orçamentos · governança · auditoria · rotação de contexto
         ▼
[LiteLLM / Portkey / provedores diretos]
         │
         ▼
[Anthropic / OpenAI / Bedrock / Azure]

Capturas de tela

Visão geral — gastos, economia de cache, tokens, solicitações bloqueadas e sinalizadores de governança rapidamente.

Aplicação de orçamento rígido — ultrapassar o limite retorna um 402 no gateway, antes que a requisição chegue ao provedor.

Governança de egresso — uma requisição carregando uma chave AWS é bloqueada com um 451; apenas a categoria é registrada, nunca o valor.

Atividade — cada requisição com um status distinto: sucesso · cache hit · rate limited · modelo bloqueado · orçamento excedido · governança bloqueada.

Configurações — CRUD completo para organização, credenciais do provedor, equipes, orçamentos e chaves virtuais.

Por quê

Os endpoints privados Bedrock / Vertex / Azure + BAAs sem treinamento resolvem o canal para o fornecedor. Eles não informam à equipe financeira quem gastou os $40k, não capturam segredos na saída, não fornecem um registro para auditores e não mostram onde a rotação de contexto está queimando seu orçamento de tokens. Essa é a lacuna que o Conduit preenche — sem nunca ver seus prompts.

O que você obtém

• Atribuição de custo por engenheiro / por chave / por modelo — o detalhamento que uma chave de API compartilhada estruturalmente não consegue produzir.
• Orçamentos rígidos + listas de permissão de modelos — 402 com falha fechada em caso de excesso, 403 claro em modelo não permitido (nunca um downgrade silencioso).
• Governança de egresso — varredura de segredos T1 (chaves de API / tokens / chaves privadas) + lista de permissão de entidades T2-lite por organização (nomes de clientes, codinomes, códigos de negócios). Alertar → promover para bloquear uma categoria de cada vez. Registra a categoria, nunca o valor.
• Painel de rotação de contexto — agrupa requisições por tamanho de token de entrada e mostra a curva de custo-e-taxa-de-erro. O Conduit mede; nunca modificamos o prompt (isso quebraria o cache de prefixo do Anthropic).
• Exportação pronta para auditoria — cada requisição como uma linha CSV/JSON apenas com metadados.
• Chaves virtuais — engenheiros possuem chaves substitutas revogáveis; a credencial real do provedor é criptografada com AES-256-GCM no gateway e nunca toca em um laptop.

Início rápido

Opção A — executar a versão assinada (sem compilação, ~30 segundos)

Baixa as imagens assinadas mais recentes do GHCR (verificável via cosign verify, veja Postura de segurança).

# 1. Obter o arquivo compose + template env (nenhum clone completo necessário)
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. Gerar uma chave de criptografia mestre real
sed -i.bak "s|^MASTER_ENCRYPTION_KEY=.*|MASTER_ENCRYPTION_KEY=$(openssl rand -base64 32)|" .env && rm .env.bak

# 3. Baixar as imagens assinadas + iniciar
docker compose --profile app pull
docker compose --profile app up -d

# 4. Executar migrações + semear o livro de preços (uma vez)
docker exec conduit-gateway-1 pnpm --filter @finops/db db:migrate
docker exec conduit-gateway-1 pnpm --filter @finops/db seed-pricing

# → abrir http://localhost:3000/setup → criar organização / credencial / equipe / chave virtual

Fixar em uma versão específica exportando GATEWAY_IMAGE e CONTROL_PLANE_IMAGE antes de 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

Opção B — compilar a partir do código fonte (~2 minutos, para 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

Aponte qualquer ferramenta de IA para ele

export ANTHROPIC_BASE_URL=http://localhost:4000
export ANTHROPIC_AUTH_TOKEN=vk_live_…       # chave virtual do /setup
claude                                       # ou cursor / codex / aider

Passo a passo completo do zero em INSTALL.md.

Funciona com o que você já executa

Como o Conduit se compara

O LiteLLM é excelente em aliasing e roteamento de modelos — o Conduit adiciona a camada que suas equipes de segurança e finanças pediram. O Portkey é a sobreposição de funcionalidades mais próxima, mas é enterprise de código fechado quando você precisa de governança + on-prem. O Helicone é apenas observabilidade (informa para onde os tokens foram; não controla para onde vão).

Honesto sobre o que NÃO está aqui

• Nenhuma certificação SOC 2 / HIPAA / ISO ainda. Não vamos reivindicar uma que não temos. Projetamos o Conduit para suportar sua auditoria e fornecer os artefatos (SBOM, imagens assinadas, whitepaper de segurança, CAIQ-lite). Veja SECURITY.md para a postura completa.
• Nenhum SSO / SAML / RBAC ainda — token de admin + senha do dashboard como porta de entrada hoje. No roadmap quando um comprador pedir.
• Streaming do Bedrock não está pronto (framing binário do AWS event-stream). O /invoke não-streaming do Bedrock funciona.
• Adaptador do Google Vertex não foi construído.
• Governança T2 completa baseada em ML (inferência de tipo de entidade) não foi construída — apenas a versão lite (lista de permissão de entidade colada pelo operador). Construída contra o tráfego real de um parceiro, não antes.

Postura de segurança

O Conduit executa inteiramente em sua própria nuvem — nenhum fornecedor no caminho da requisição, nenhum phone-home, passível de air-gap. Veja SECURITY.md para o whitepaper (diagrama de fluxo de dados, o que é armazenado, criptografia, autenticação com falha fechada, postura de conformidade, modelo de ameaça).

• As imagens de contêiner são assinadas via Sigstore cosign (OIDC sem chave) e acompanham uma atestação CycloneDX SBOM. Publicado em ghcr.io/anee769/conduit-gateway e ghcr.io/anee769/conduit-control-plane a cada tag git v* (veja .github/workflows/release.yml). Verifique qualquer tag publicada:
  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
  

• Gere um SBOM localmente a qualquer momento com bash scripts/sbom.sh.
• 86 testes automatizados executados em cada PR — incluindo o vetor de referência AWS SigV4 e um invariante de privacidade de governança (o valor do segredo/entidade nunca aparece em eventos armazenados).

Arquitetura (resumidamente)

• apps/gateway — Hono no Node, o plano de dados do caminho crítico. Sem etapa de compilação (tsx). Cliente ClickHouse zero-dep + ioredis.
• apps/control-plane — Next.js 15 / React 19 dashboard + API admin + assistente de /setup na primeira execução.
• packages/db — Schema Drizzle, criptografia AES-256-GCM, hash de chave, preços + orçamentos.
• Armazenamentos: Postgres (config / identidade / orçamentos / preços) + ClickHouse (somente anexar usage_events) + Redis (cache + limites de taxa + contadores de orçamento em tempo real).

Ciclo de vida da requisição (apps/gateway/src/routes/proxy.ts):

auth (vk) → limite de taxa → lista de permissão de modelos → verificação de orçamento
         → varredura de governança (segredos T1 + entidades T2-lite)
         → consulta de cache → resolver credencial → adapter.prepare()
         → encaminhar + bifurcar stream (cliente intacto; ramo de medição em segundo plano)

Testes

bash scripts/run-tests.sh             # suíte completa de testes unitários + sistema ativo (72 testes)
bash scripts/run-tests.sh --unit-only # lógica pura, sem necessidade de pilha Docker
pwsh scripts/run-tests.ps1            # equivalente no Windows

CI (.github/workflows/ci.yml) executa ambos os jobs em cada PR — mescle apenas quando estiver verde.

Contribuindo

PRs são bem-vindos. Caminho rápido:

git checkout -b feat/minha-alteracao
# …
bash scripts/ci-local.sh              # executa as mesmas verificações que a CI executa
bash scripts/ci-local.sh --fast       # apenas typecheck + unitário, sem Docker
git push -u origin feat/minha-alteracao
gh pr create --base dev

Fluxo de branches: feature → dev → master. CI deve passar antes da mesclagem.

Licença

Licença Apache 2.0 — mesma licença do Kubernetes, Terraform, Kafka. Use comercialmente, modifique, distribua; por favor, não reivindique o Conduit como seu próprio trabalho.

Links

• Site: getconduit.vercel.app
• Postura de segurança: SECURITY.md
• Executar com LiteLLM: docs/run-with-litellm.md
• Guia de instalação: INSTALL.md