convez.ai
MCP ServerSegurançaAvançado
Blekline

Blekline — Plano de Controle de Ingresso para Agentes IA

Blekline/blekline-oss

Govern, mask, and audit every agent call before it touches your systems

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server que funciona como um plano de controle de ingresso para agentes de IA, implementando mascaramento de dados sensíveis, aplicação de políticas de acesso e auditoria completa de chamadas. Coloca governança entre seus agentes e as ferramentas que eles acessam, garantindo conformidade com regulações como a Lei de IA da UE.

Instalação

$npx convez-ai Blekline/blekline-oss

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
100%
Último commit
há 4 semanas
Versão
v0.2.2-nhim-audit
Issues abertas
1
Contribuidores
1

Casos de uso

  • Proteger dados sensíveis (credenciais, PII) de serem expostos em contextos de modelo
  • Implementar políticas de acesso granular para agentes autônomos
  • Auditoria e rastreamento completo de chamadas de ferramenta para compliance regulatório
  • Prevenir execução não autorizada de comandos críticos em bases de dados e APIs

Veredito

Solução madura e essencial para times que deployam agentes IA em produção. Endereça o gap crítico de governança entre agentes e recursos, com suporte a EU AI Act e compliance. Arquitetura sólida (proxy + SDK) e open core tornam viável desde POCs até enterprise.

README

A tradução para o português deste README ainda está na fila.


The problem nobody wants to talk about

Cursor writes your code, Claude answers your support tickets, autonomous pipelines touch your databases, your APIs, your customers' data. The ecosystem is accelerating, MCP servers let agents pick up tools like apps pick up plugins, and that is genuinely exciting.

But here's the thing: your agents have no idea what they're not allowed to do. They'll happily pass an AWS key to a model context window. They'll call a tool with a customer's email as an argument. They'll execute a shell command that wasn't in the plan. Not out of malice, out of the fundamental nature of language models: they optimize for task completion, not for the organizational policies you haven't written yet.

This is the AI governance gap. And right now, there's nothing sitting between your agents and everything they can touch.

Why this is becoming urgent

The EU AI Act isn't theoretical anymore. GPAI obligations have been enforceable since August 2025. Transparency and human oversight requirements land in August 2026. High-risk system conformity assessments follow. Fines reach up to €35 million or 7% of global turnover for the worst violations. And these rules aren't just about the model, they're about the systems you build with them: how you govern tool access, how you audit decisions, how you prove a human was in the loop.

Meanwhile, enterprises running AI at scale, sandboxed, parallelized, thousands of agent calls, have no native answer for: what happened in that session? Who authorized that tool call? Did any PII leave the context window?

The compliance question is catching up to the capability question. And most teams aren't ready.

What Blekline is

Blekline is an open-core MCP ingress control plane, infrastructure that sits between your agents and everything they can touch. It does three things, in real time, before any LLM sees a prompt or any tool executes:

Mask - strip PII, secrets, and sensitive context from prompts before they hit model APIs (MCP Server docs)

Enforce — evaluate tool calls against policy; allow, flag, or block before execution

Audit — emit a structured, tamper-evident event trail for every agent interaction

You can run it locally in two minutes. You can deploy it as a sidecar alongside any L1 sandbox (Daytona, Modal, E2B, Cloudflare, Vercel Sandbox). You can plug it into Cursor, Claude Desktop, or Codex today, without changing your agent code. This is the infrastructure that makes governed AI deployment real: not a checkbox, not a policy document, but a running system that enforces your intentions at the call level.


Start here

pnpm install && pnpm build:packages
export BLEKLINE_WORKSPACE_TOKEN="blw_..."
export BLEKLINE_API_URL="https://app.blekline.com"
export BLEKLINE_CLIENT_SURFACE="sdk"
pnpm demo:mcp-smoke

Headless guide: cli/README.md · CI template: ci/

Connect Blekline

SurfacePathBLEKLINE_CLIENT_SURFACE
CLI / SDKcli/sdk
CI / CDci/sdk
Claude Code.claude/settings.json.exampleclaude-code
Cursor.cursor/mcp.json.examplecursor
GitHub Copilot.vscode/mcp.json.examplegithub-copilot
Continue.vscode/continue.config.json.examplecontinue
Claude Desktopconfig/claude_desktop_config.json.exampleclaude-desktop
Codex.codex/config.toml.examplecodex

Full index: integrations/README.md · Docs: app.blekline.com/docs

pnpm generate:mcp-configs          # *.example configs
pnpm verify:integrations           # manifest + schema checks

In any client: "Use blekline_mask_prompt on: Contact Jane at jane@acme.com — API key AKIAIOSFODNN7EXAMPLE"

Architecture

Blekline sits at Layer 4 — between L5 agents (Cursor, Claude, Codex) and L1 sandboxes (Daytona, Modal, Vercel Sandbox, Cloudflare, E2B) and model APIs.

L5 Agents → L4 Blekline (mask · enforce · audit) → L1 sandbox MCP / model APIs

AI Enablement Stack · Architecture · Trust boundaries · Latency SLO

Open core vs cloud

CapabilityOSS (this repo)Cloud (app.blekline.com)
MCP server / proxyYesYes
Local tool + secret enforceYes (@blekline/contracts)Yes
Azure authoritative PII mask—Yes
Workspace fleet policy (SSE)—Yes
Investigations / billing—Yes

License: AGPL for proxy/server (self-host or buy cloud). Apache for contracts/SDK (embed in your agent stack).

Who this is for

Developers building with Cursor, Claude Desktop, or Codex who want their agents to stop leaking secrets and start respecting tool boundaries.

Platform teams deploying AI workloads in L1 sandboxes who need a governance layer that travels with the execution environment.

Enterprise architects preparing for EU AI Act compliance — specifically human oversight, audit trails, and tool call transparency requirements that become enforceable in August 2026.

Open source contributors who believe that the infrastructure for safe AI should be auditable, forkable, and owned by the community — not locked inside a vendor's cloud.

Packages

PackageInstallLicense
@blekline/mcp-servernpm i @blekline/mcp-serverAGPL-3.0
@blekline/mcp-proxynpm i @blekline/mcp-proxyAGPL-3.0
@blekline/clientnpm i @blekline/clientApache-2.0
@blekline/contractsworkspace / embedApache-2.0
ingress-proxyDocker / HelmAGPL-3.0

OpenAPI: packages/contracts/openapi.yaml

MCP tools

ToolPurpose
blekline_mask_promptRedact PII / secrets before model context
blekline_classify_riskRisk tier → allow / review / block
blekline_evaluate_tool_callPolicy on tool name + arguments
blekline_emit_eventMetadata audit trail

Proxy path: agent → Blekline → allow/mask/block → downstream MCP (Daytona, E2B, Modal, Cloudflare, Vercel Sandbox, custom).

Client libraries

TypeScript

npm install @blekline/client
import { BleklineClient } from "@blekline/client";

const blekline = new BleklineClient({
  workspaceToken: process.env.BLEKLINE_WORKSPACE_TOKEN!,
  metadata: { clientSurface: "sdk" },
});

await blekline.mask({ text: "alice@corp.com", platform: "MyAgent" });
await blekline.enforceToolCall({
  toolName: "run_shell",
  arguments: { cmd: "curl https://api.internal/deploy" },
});

Python

pip install blekline-client

Local-only (no API token)

import { enforceToolCallLocally, scanTextForSecrets } from "@blekline/contracts";

scanTextForSecrets("export AWS_KEY=AKIAIOSFODNN7EXAMPLE");
enforceToolCallLocally({
  toolName: "run_shell",
  arguments: { cmd: "export AWS_KEY=AKIAIOSFODNN7EXAMPLE" },
  requestId: "local-1",
});

Works with

Full integration guides on app.blekline.com/docs — not mirrored in this repo.

L5 agent clients

ClientGuide
HubAgent clients
ContinueContinue MCP
GitHub CopilotCopilot MCP
OpenHandsOpenHands
Sourcegraph CodyCody

L2 model providers

ProviderGuide
HubModel providers
Azure OpenAIAzure stack
AWS BedrockBedrock stack
OpenRouterOpenRouter stack

L2 frameworks & RAG

IntegrationGuide
HubFrameworks & RAG
LangChainLangChain stack
PineconePinecone stack

L3 eval & safety

PartnerGuide
HubEval & safety
LangSmithLangSmith stack
GuardrailsGuardrails stack

L1 sandboxes

ProviderIntegration guide
All fiveSandbox providers hub
DaytonaDaytona stack
ModalModal stack
Vercel SandboxVercel Sandbox stack
CloudflareCloudflare stack
E2BE2B stack

Deploy

ModeCommand / link
MCP (global)npx -y @blekline/mcp-server
Edge sidecarpnpm docker:ingress — Helm
L1 sandboxesSandbox providers

Development

Client demos and smoke tests: demo/README.md.

git clone https://github.com/Blekline/blekline-oss.git && cd blekline-oss
pnpm install && pnpm build:packages && pnpm demo:mcp-smoke

Documentation

All docs: app.blekline.com/docs

DocLink
Quick startintroduction/quick-start
EU AI Act & complianceintroduction/eu-ai-act
AI Enablement Stackintroduction/ai-enablement-stack
MCP proxymcp/proxy
Cursor setupmcp/cursor

Community & design partners

Questions or integration feedback — GitHub Discussions (Q&A, integration feedback).

Design partners — shipping agents in production and want help wiring Blekline into your stack (proxy or MCP server)?

Contributing

CONTRIBUTING.md · SECURITY.md · CHANGELOG.md

Private Blekline team: develop in the blekline monorepo, run pnpm sync:oss from the root repo.

License

ComponentLicense
mcp-server, mcp-proxy, ingress-proxyAGPL-3.0
contracts, client, client-pythonApache-2.0

Managed SaaS at app.blekline.com is not licensed under this repository.

Ver o original no GitHub

Bom para

Relacionados