brin
integrations

LangChain

Add brin to LangChain. Guard DynamicStructuredTool callbacks so brin checks every artifact before the tool touches external context.

LangChain tools are regular functions behind a tool interface. that means you can make brin part of the tool path itself: check the artifact first, then run the external action only when the verdict allows it.

##how it works

put a shared brin helper in front of any DynamicStructuredTool or tool() callback that reaches outside your system. that keeps the enforcement deterministic even if the model ignores natural-language guidance.

##setup

1. Add a shared helper:

TypeScript
type BrinVerdict = "safe" | "caution" | "suspicious" | "dangerous";
 
async function assertBrinAllowed(
  path: string,
  allowed: BrinVerdict[],
): Promise<void> {
  let response: Response;
 
  try {
    response = await fetch(`https://api.brin.sh/${path}`);
  } catch {
    return;
  }
 
  if (!response.ok) {
    return;
  }
 
  const verdict = response.headers.get("x-brin-verdict") as BrinVerdict | null;
  const score = response.headers.get("x-brin-score");
 
  if (verdict && !allowed.includes(verdict)) {
    throw new Error(
      `brin blocked ${path}: verdict=${verdict} score=${score ?? "unknown"}`,
    );
  }
}

2. Guard external tools before they run:

TypeScript
import { DynamicStructuredTool } from "@langchain/core/tools";
import { z } from "zod";
 
async function cloneRepo(owner: string, repo: string) {
  // Replace this with your existing clone or sync path.
  return { owner, repo, queued: true };
}
 
export const cloneRepository = new DynamicStructuredTool({
  name: "clone_repository",
  description: "Clone a repository after brin approves it",
  schema: z.object({
    owner: z.string(),
    repo: z.string(),
  }),
  func: async ({ owner, repo }) => {
    await assertBrinAllowed(`repo/${owner}/${repo}`, ["safe"]);
    return JSON.stringify(await cloneRepo(owner, repo));
  },
});
 
export const readPage = new DynamicStructuredTool({
  name: "read_page",
  description: "Fetch a web page after brin approves it",
  schema: z.object({
    url: z.string().url(),
  }),
  func: async ({ url }) => {
    const target = new URL(url);
    const pagePath = `page/${target.host}${target.pathname}`;
 
    await assertBrinAllowed(pagePath, ["safe", "caution"]);
 
    const response = await fetch(url);
    return await response.text();
  },
});

##extending the pattern

apply the same helper to every tool that handles untrusted context:

  • package install tools: npm/<package>, pypi/<package>, crate/<package>
  • repo readers and cloners: repo/<owner>/<repo>
  • browsing or scraping tools: domain/<domain> or page/<domain/path>
  • MCP and skill loaders: mcp/<owner>/<repo> and skill/<owner>/<repo>

if you use LangChain's tool() helper instead of DynamicStructuredTool, same pattern: call brin first inside the tool function, then execute the side effect.