MCP + API for Claude: Programmatic Access to Your Curated Knowledge Graph

The Shift Toward In-Tenant AI Data Layers

AmLaw firms spent the last two years moving AI inside their own tenant. The pattern is clear: generic SaaS AI is fine for brainstorming, but when you need your own work, your matters, your clauses, your M&A playbooks, you need the model to read from sources you control. iManage, SharePoint, NetDocuments. Not a disconnected vector index in someone else's cloud.

But control isn't enough. Firms also need access. Once the knowledge graph is curated and living in your tenant, the tools that need to read it should be able to read it programmatically. Not just the Atlas UI. Not just Claude via a chat. Custom scripts, case-management integrations, in-house ops dashboards.

The constraint has been: expose programmatic access without losing your permission model. That's the hard problem.

What We Built

AtlasAI Singularity v6 now exposes the firm's curated knowledge graph via the Model Context Protocol (MCP) and a public REST API. Claude, Claude Code, and any MCP-aware tool can read:

• Matters and their constituent documents
• Extracted clauses and structured findings
• Practice-area Lists and reusable agent workflows
• Firm precedent and playbook content

All with the same access controls as the in-app experience. If a user can't see a matter in Atlas Workspaces, they can't read it via the API. If a document is shared with a team in Lists, the API honors that boundary.

The API is straightforward. Query matters by name or metadata. Fetch document content or parsed structure. List extracted clauses by type. Read agent task outputs. No new permission layer. No token system. The firm's existing tenant access controls flow through.

MCP surfaces the same data as native capabilities for Claude and MCP-aware tools, so Claude can talk to the graph in its own request loop without going through the web UI.

Why This Matters at Scale

Large firms manage thousands of active matters. Each matter has hundreds of documents. Each document has dozens of clauses that matter for downstream work.

The old pattern: someone exports the data out of iManage into a spreadsheet or a SaaS tool, manually curates it, and feeds it to a model. Two problems. First, it's slow and manual. Second, you've now got that data in two places, and the export is stale the moment the source document changes.

With the API and MCP, the firm's graph is the source of truth. Any tool that needs to read it reads the live curated graph. The M&A team's custom deal dashboard reads the same clause extractions that the Atlas Workspace review is using. A compliance script flags indemnification schedules in real time, not against yesterday's export.

This week we shipped integration connectors for Microsoft 365 and Google Drive, plus SharePoint list/file browsing. That means the graph now ingests from iManage, SharePoint, OneDrive, Google Drive, and email continuously. As new documents land, Atlas agents classify them, link them to existing matters, extract clauses, and refine the graph. The API reads that live curated graph.

What This Enables

Custom matter dashboards. An M&A team wires Claude to their matter Workspace via MCP. Claude reads the documents, extracted findings, and deal checklists from the curated graph and builds a real-time matter status dashboard. No copy-paste. Lives off the graph.

Compliance automation. A risk team builds a script that polls the API daily, fetches all active matter documents, searches for specific clause patterns, and flags risky language. Reads the same curated graph that the Workspace review agents are reading.

Case-management sync. An ops team wires their case-management system's API to Atlas via the public API. When a new matter is created in Atlas, the ops system auto-creates the case. When documents are uploaded to a Workspace, the ops system gets a notification and can pull the curated metadata.

In-house agent orchestration. A firm builds a custom agent that coordinates across multiple tools. The agent reads from Atlas via MCP to fetch matter details, queries a contract database via another MCP server, and writes findings back to a Slack channel. All reading live, curated data.

How to Try It

MCP + API is live in Singularity v6 for all tenants. If you're on v6, generate an API token in the trust center. Write a simple script that queries `/api/matters`, `/api/documents`, or `/api/clauses`. Or connect Claude Code to the MCP server and ask Claude to read your matter.

The boundary between in-app and programmatic work is now gone. Your curated knowledge graph is your data layer. Tools and scripts read from it the same way the UI does.