AI in Feith · Integration

Your AI tools, connected to your records.

Feith MCP exposes the platform to the AI tools your team already uses (Claude, GitHub Copilot, OpenAI products, and your own in-house agents) over Model Context Protocol, the open standard for AI-tool integration. Each one runs with the user's permissions and queries your governed content directly.

Request a walkthrough All six capabilities ›

1 Open standardSpeaks Model Context Protocol natively, built in at the core

0 Copies, syncs, or exportsNothing is replicated into a separate AI store; your AI queries Feith live and gets back only what that query returns

1 Permission model, inheritedThe tool runs with the user's permissions, and sees only what they can

Every Call written to the logEach request your AI makes is recorded in the audit trail

The problem

Your AI works everywhere except your records.

Agencies are standing up Claude, Copilot, and ChatGPT for their teams. Those tools live outside Feith, so the records that matter most are the one thing they can't see, and the usual workarounds quietly break the governance you built.

Your AI lives outside Feith

The assistants your team relies on can't reach your governed content, so they help with everything except the records that matter.

Copy-paste breaks governance

The workaround is pasting records into a chat box, where sensitive content sits ungoverned, unlogged, and outside your permissions.

One-off connectors don't last

Hand-building a custom integration for each AI tool is brittle, and it breaks the moment the tool (or the model behind it) changes.

The records need to reach the AI your team already uses, under your permissions, on your audit log, with no copy of the repository living anywhere else. There's now an open standard for exactly that.

What it does

The one capability that points outbound.

Where the other five capabilities bring AI into Feith, Feith MCP sends Feith out to wherever your AI already lives. The external tool runs with the user's permissions and inherits the same permission model, and every call it makes is written to the audit log.

Speaks the industry standard: MCP is how modern AI assistants connect to external content, and Feith speaks it as a first-class platform surface.
Inherits your permission model: the tool runs with the user's permissions and is scoped to that user's access, nothing more.
Sits alongside your other sources: because it speaks the same protocol as the tool's other connections, your AI can combine a Feith answer with the rest of what it can reach.

Model Context Protocol is an open standard for connecting AI assistants to external content. Feith MCP is Feith's native implementation of it.

Worked example

Your AI tool

Claude · Copilot · ChatGPT · in-house agents

Wherever your AI already lives: no rebuild, no second copy of your records.

Feith MCP Model Context Protocol

Speaks the open standard MCP · native

The industry standard for AI-tool integration, spoken as a first-class platform surface.

Runs with the user's permissions

Inherits the same permission model: the tool sees exactly what that user is authorized to see.

One source among many

Your tool already talks to other systems this way; Feith becomes one more it can reach.

Your governed content

Feith Content Platform

Only the records that user is cleared for, returned with citations, and every call written to the audit log.

permission-inherited every call logged

How it works

Your AI asks. Feith answers, under your governance.

The connection runs over MCP. Your tool runs with the user's permissions, Feith returns only the records that user is allowed to see, and every request is written to the audit log, so outbound access is as accountable as everything else in the platform.

Where the connected tool runs decides where the answer goes. An in-boundary agent or an on-enclave client keeps everything inside your accreditation; a commercial assistant receives what your query returns, under your own agreement with that vendor. Either way Feith enforces the same permissions and writes the same audit entry.

Your AI tool sends a request

Feith MCP

Runs with the user's permissions

Your permission model & audit log

Permission-filtered records returned, with citations

Every call written to the audit log

Why it's different

Bring your own AI

Connect the assistants your team already uses, with no rebuild and no new tool to learn. They keep the same workflow and gain one new source.

Governed like a Feith user

The tool inherits the same permissions as the person using it, so it can never reach a record they couldn't open themselves.

Every call on the record

Each request your AI makes lands in the same audit log as everything else, so an outside tool leaves the same defensible trail an employee would.

What connects

One protocol, every assistant.

Any MCP-capable client can connect, and each one queries Feith under the same governance. These are the ones teams ask about most.

Claude Desktop

Native MCP connector

Query governed records without leaving the desktop app.

GitHub Copilot

MCP server endpoint

Feith content pulled in alongside code context.

ChatGPT

MCP connector

Governed answers inside the chat your team already uses.

In-house agents

MCP client, your build

Your own agent queries Feith under the operator's permissions.

Explore the rest of AI in Feith

Five more capabilities, each its own deep-dive.

These are the other capabilities in the AI in Feith family — separate tools that each share the same permission model, the same audit trail, and your choice of large language model.

Back to AI in Feith ›

Get started

Bring your own AI. Govern it like a Feith user.

Tell us which AI tools your team already uses. We'll walk you through connecting them to governed content over MCP, and show the permission filtering and audit log in action.