Claude Legal Research MCP: How to Use Claude for US Legal Research

To use Claude for legal research, connect it to a legal research MCP server. MCP (Model Context Protocol) lets Claude call live tools instead of guessing from training data, so it reads real statutory text and returns citations you can open and check. You add the server once (a connector or a short JSON config), then ask Claude legal questions in plain English. This guide shows the exact config and a real query, end to end.

Anthropic made this the default story for law on May 12, 2026, when it launched Claude for the legal industry with 20+ MCP connectors and 12 practice-area plugins (Anthropic, May 2026). Legal research is one of the headline use cases. The rest of this post is how to wire it up and what it looks like once it works.

Why Claude Hallucinates Citations Without MCP

Ask Claude what the Securities Exchange Act says about manipulative trading and you'll get a clean textbook answer. Ask it for the operative text of 17 C.F.R. § 240.10b5-1, subsection by subsection, with the affirmative-defense conditions in the order the rule lists them, and it falls apart.

It will hallucinate a section number, quote language from a version the agency superseded years ago, or attribute a state code section to the wrong state. The paraphrase is usually close. The citation under it is the part that gets you sanctioned.

This isn't Claude's fault. LLMs are trained on general web data. They don't have access to structured legal databases, and they certainly don't have access to the US Code, the CFR, and 52 state and territory codes as addressable, current text.

But what if they could?

A Claude legal research MCP fixes this. You give Claude (or Cursor, or VS Code Copilot) an MCP server that exposes US primary-law tools, and you can use Claude for legal research without crossing your fingers on every cite.

When you ask what a provision says, Claude doesn't guess. It resolves the citation, pulls the published text, and hands back the government URL that text came from.

One clarification before we go further, because it shapes everything below. The public REST API and the vaquill-mcp server are statutes, regulations, and codes: the U.S. Code, the CFR, 52 state and territory statute codes, the U.S. Constitution and state constitutions, the Federal Rules and state court rules, state administrative regulations, the Federal Register, federal and state agency guidance, Executive Orders, the Sentencing Guidelines, and US tax treaties. Plus a change-monitoring layer over all of it.

It does not do case law, citation networks, treatment history, or open-ended legal Q&A. If you want those, pair it with a case-law server; the comparison table below covers the options.

I'll walk you through the setup and show you what this looks like in practice. Five minutes, and you'll have Claude reading real law for you. No coding required.

If you're weighing the AI research stack as a whole, we wrote up how this replaces a Harvey-style setup with Claude plus an MCP server.

TL;DR

• Use Claude for legal research by connecting a legal research MCP server. LLMs invent citations because they have no real legal database behind them. MCP gives Claude live tools that read from one.
• Since the May 12, 2026 Claude for Legal launch, you can add many legal MCP connectors from Claude's built-in directory; for a self-hosted server, you edit one JSON config block (about two minutes).
• Connect the statutes server once and Claude can read roughly 4M sections of US primary law on demand: the U.S. Code, the CFR, 52 state and territory codes, constitutions, court rules, state regulations, the Federal Register, agency guidance, and Executive Orders.
• You get nineteen tools. Ten read the corpus: search, resolve a Bluebook citation, section metadata, full text, neighboring sections, batch metadata, browse the hierarchy, list the bodies of law, coverage and freshness, and pricing. Nine watch it for changes.
• Every section comes back with the government URL it was published at, so you verify against the publisher rather than against us.
• Works in Claude Desktop, Claude Code, Cursor, VS Code (Copilot), and Windsurf.
• This server is not a case-law server. No opinions, no citation networks, no treatment history, no ask-anything endpoint. Run CourtListener alongside it if you need those.

Part of our MCP and developer guide series.

For related MCP / API / developer coverage, see Legal Research from Inside Cursor and Claude Code: The MCP Way and Adding Legal Research to Your AI Agent with MCP.

Why Use Claude for Legal Research (and Where It Breaks)

Claude is a strong reasoning engine, but on its own it has no idea whether the section it just quoted is real, current, or from the right jurisdiction. The fix is not a better prompt. It is giving Claude a tool that reads from an actual legal database.

The rest of this post is how to do that, and what it looks like once it works.

What is MCP?

MCP stands for Model Context Protocol. Anthropic released the spec in late 2024, and it has since been adopted across most major AI coding tools.

Think of MCP as a plugin system for LLMs. Instead of an AI assistant being limited to its training data and whatever you paste into the chat window, MCP lets it call external tools, fetch live data, and take actions on your behalf.

The AI sees a list of available tools with descriptions, decides which ones to call based on your question, and folds the results into its response.

It's the difference between an AI that knows about legal research and an AI that can actually do legal research.

Here is the loop, end to end. Claude reads your question, picks a tool, the MCP server queries a real legal database, and the citations flow back into the answer before Claude ever writes a word:

Two Ways to Connect a Legal Research MCP to Claude

There are two paths, and the launch in May 2026 added the first one.

1. The Claude connector directory (point and click). On May 12, 2026, Anthropic launched Claude for the legal industry with more than 20 MCP connectors, including legal-research providers (Anthropic, May 2026). To add one, open Claude on web or desktop, go to Customize then Connectors then Browse Connectors, pick the provider, and authorize it. No config file. Some connectors need a paid account with that provider (for example, the CoCounsel Legal connector needs a Thomson Reuters subscription).

2. A self-hosted MCP server (one JSON edit). Any MCP server, listed in the directory or not, can be wired into Claude Desktop, Claude Code, Cursor, VS Code, or Windsurf with a short config block. This is the path the rest of this guide uses, because it works the same in every client and you control the API key.

Which Legal Research MCP Connector Should You Use?

The May 12, 2026 launch put several legal research providers into Claude at once. They are not interchangeable. Some hand Claude raw API access to a database, some ride on a paid subscription you already have, and some cover a slice of primary law that nobody else normalizes. Pick by what you already pay for and which half of primary law you need.

The honest read: if you want free primary-source case law and don't mind a raw API surface, CourtListener is the default. If your firm already runs on Westlaw, CoCounsel is the least friction. Neither of them gives you a clean, normalized, multi-state statutes and regulations corpus, and that is the slice a server like Vaquill AI covers. There is no reason to pick only one; MCP lets you attach several and let Claude choose. We wrote up how to run three of them side by side.

What You Get: Nineteen Research Tools

When you connect the MCP server, your AI assistant gets nineteen tools. Ten of them read the corpus. Nine of them watch it and tell you when it changes. You don't need to memorize any of this; Claude picks the tool from how you phrase the question.

But it helps to know what's available so you can ask better questions.

The list is not hardcoded in the package. The server fetches the live API spec at startup and generates its tools from it, so a new endpoint shows up without a package upgrade. It also appends each tool's current credit cost to that tool's own description, pulled from the pricing endpoint at the same moment, so what Claude sees is what you're charged.

The ten that read the corpus

Search US primary law (search_us_statutes): Semantic search across everything at once, or narrowed with corpusType and state. The corpora are the U.S. Code, the CFR, the statutory codes of 52 states and territories, the U.S. Constitution and the state constitutions, the Federal Rules and state court rules, state administrative regulations, the Federal Register, federal and state agency guidance, Executive Orders and other Presidential documents, the Sentencing Guidelines, and US income tax treaties. Results carry the citation, the title hierarchy, and a link to the official source document.

Resolve a citation (resolve_statute_citation): Hand it a Bluebook string (42 U.S.C. 1983, 16 C.F.R. 444.1, Del. Code Ann. tit. 13, 1301) and it returns the exact section that citation names, confirmed against the corpus. A pinpoint subsection like 42 U.S.C. 1983(b)(2) resolves to the parent section and echoes the subsection back. When it cannot resolve, it says so rather than improvising, and resolved: false means unverified, not current.

Get section metadata (get_us_statute_section): Citation, title hierarchy, breadcrumb, and links to every format the publisher offers (HTML, PDF, XML, plain text, DOCX) for a single section, addressed by its actId. Use it to preview a section before pulling the text.

Get the full text (get_us_statute_section_text): The operative language, in styled HTML and plain text, with cross-references and paragraph numbering as published in the official source. Pass structured=true and you also get the body as nested Markdown plus a subsection tree you can address by pincite, so (b)(2) is a node with its own full pinpoint citation instead of a substring you have to go find.

Get neighboring sections (get_section_neighbors): The sections immediately before and after, in statutory order. This is the one that fixes the classic mistake of reading a section without its definitions, which sit a few sections back, or its exceptions, which sit a few forward. Search can't answer "what comes next", because relevance ranking is not statutory order. Neighbors never cross the containing chapter, and ordering is natural rather than lexicographic: 9 before 10, 1983 before 1983a.

Batch section metadata (get_sections_batch): Metadata for up to 50 sections in one call, in the order you asked for them, with misses reported separately so you can zip results back onto the ids that produced them. Enriching a 50-result page used to be 50 round trips.

Browse the hierarchy (list_statute_divisions): Walk a code one level at a time, in statutory order. USC titles, then the chapters in Title 42, then the sections in Chapter 21. Same for CFR parts, and for a state's individual codes (corpusType=STATE&state=tx gives you the Texas codes, then drill into the Penal Code). This is how you enumerate a body of law top to bottom without searching for it.

List the bodies of law (list_statutes_laws): The catalog. Every distinct body of law in a jurisdiction (a state's statutes, a state's regulations, the U.S. Code, the federal court rules) with its corpusType, a human name, and a section count. Free.

Check coverage and freshness (list_statutes_coverage): The coverage matrix, per jurisdiction and per corpus, with document counts. More usefully, it tells you when we last pulled that body of law from its publisher, how often we do, and whether that is on schedule, overdue, failing, or never started, plus which pairs are paused or retired. It is what turns a count into a count with an age on it. Free.

Check pricing (get_pricing): Current per-endpoint credit costs and the credit-to-dollar rate. Free and unauthenticated.

The nine that watch it for changes

This half is what no case-law connector has. A board is one tracked source, identified by its corpus and its state. A watch is your subscription to one.

List watchable boards (list_boards): Every board you can subscribe to, with when we last pulled it, how often we do, and whether we're still polling it. Read those together before treating silence on a watch as "nothing changed".

Create a watch (create_watch): Subscribe by webhook, email, or both. Webhook URLs are validated against an SSRF blocklist on acceptance and again on every dispatch. Set a signing secret and every delivery carries an HMAC-SHA256 signature over the raw body. The scope field narrows a watch from a whole source down to one hierarchy prefix (say, 21 CFR part 314), one exact section, or one named sub-source.

List your watches (list_watches): Every watch you own, with its id and a last-notified health signal.

Update a watch (update_watch): Pause with isActive: false and resume with true, rotate a webhook URL or signing secret, or re-scope it. A paused watch keeps its history and config.

Delete a watch (delete_watch): Immediate and permanent, and it takes the delivery history with it. Pause instead if you only want to stop the noise.

List what changed (list_watch_changes): The sections this watch's source added, amended, or removed. Not "3 sections changed" but which three, with citations. Safe to poll alongside a webhook: it is read-only and there is no watermark to disturb.

Diff one change (get_watch_change_diff): The section's text before and after that specific change, so you can see the edit rather than re-read the whole section.

Delivery history (list_watch_deliveries): Recent webhook delivery attempts for one watch, newest first. This is where you look when your endpoint stopped receiving.

Send a test delivery (test_watch): Fire a one-off test at your webhook or email so you can prove the pipe works before you rely on it. It arrives tagged as a test event and is deliberately never persisted to the delivery history.

The corpus behind those tools runs to over 4M sections: 54,853 in the U.S. Code, 219,119 in the CFR, and about 1.93M across the statutory codes of all 52 jurisdictions, plus regulations, constitutions, court rules, and the federal document corpora.

For more on how Vaquill AI's tools work and how to query them, see our MCP and developer guide series.

Setup: Claude Desktop

The entire setup takes about two minutes. You need two things: an API key and a config file edit.

Step 1: Get Your API Key

Sign up at app.vaquill.ai if you haven't already. Navigate to your API settings and generate a key. It will start with vq_key_.

Vaquill AI is self-serve; sign up to start, and current pricing is shown in your dashboard.

Step 2: Edit the Config File

Claude Desktop reads its MCP configuration from a JSON file. Settings > Developer > Edit Config opens it for you. On macOS, the path is:

~/Library/Application Support/Claude/claude_desktop_config.json

On Windows:

%APPDATA%\Claude\claude_desktop_config.json

On Linux:

~/.config/Claude/claude_desktop_config.json

Open (or create) that file and add the server entry:

{
  "mcpServers": {
    "vaquill": {
      "command": "uvx",
      "args": ["vaquill-mcp"],
      "env": {
        "VAQUILL_API_KEY": "vq_key_your_key_here"
      }
    }
  }
}

That file takes stdio servers only: a command, its args, and its env. It does not take a remote url. If you would rather use the hosted server than the package, add it as a connector instead: Customize > Connectors > Add custom connector, URL https://mcp.vaquill.ai/s/_, then a Request header named Authorization with the value Bearer vq_key_your_key_here. Claude sends that value exactly as typed and adds no scheme of its own, so it reads Bearer ... and never Authorization: Bearer .... (Request headers on a custom connector are a beta feature, enabled per account.) You can also skip the header entirely and paste https://mcp.vaquill.ai/s/vq_key_your_key_here, which puts the key in the URL.

Step 3: Restart Claude Desktop

Quit and reopen Claude Desktop. You should see a small hammer icon in the chat input area. Click it, and you'll see the nineteen tools listed. That's it. You're connected.

Setup: Claude Code (Terminal)

If you use Claude Code in the terminal, setup is a single command:

claude mcp add --scope user vaquill -e VAQUILL_API_KEY=vq_key_your_key_here -- uvx vaquill-mcp

--scope user registers the server for every project. The default scope is local, which registers it only for the directory you happened to run the command in.

Pass the key with -e rather than exporting it in your shell. An export line in .bashrc or .zshrc is not read when Claude Code is launched from an IDE, so keeping the key with the registration is what makes it survive.

For the hosted server instead of the package, register it over HTTP:

claude mcp add --transport http --scope user vaquill \
  https://mcp.vaquill.ai/s/_ \
  --header "Authorization: Bearer vq_key_your_key_here"

--header and -e are variadic, so they have to come after the name and the URL. Put them first and the URL is swallowed into the flag's value list.

Setup: Cursor

Cursor reads MCP servers from ~/.cursor/mcp.json, or from .cursor/mcp.json in a repo root when you want the config to travel with one project. Open that file (Cursor Settings > MCP has a button for it) and add this configuration:

{
  "mcpServers": {
    "vaquill": {
      "type": "stdio",
      "command": "uvx",
      "args": ["vaquill-mcp"],
      "env": {
        "VAQUILL_API_KEY": "vq_key_your_key_here"
      }
    }
  }
}

Restart Cursor, and the tools will be available in your AI chat panel. For the hosted server, drop type, command, args and env, and give it a url plus a headers object instead; Cursor takes the transport from which of those keys are present.

Setup: VS Code (GitHub Copilot)

For VS Code with GitHub Copilot, MCP servers live in their own file, .vscode/mcp.json, not in settings.json:

{
  "servers": {
    "vaquill": {
      "type": "stdio",
      "command": "uvx",
      "args": ["vaquill-mcp"],
      "env": {
        "VAQUILL_API_KEY": "vq_key_your_key_here"
      }
    }
  }
}

That file is per-project. To get the same server in every workspace, run the MCP: Open User Configuration command from the Command Palette and put the same servers block in the file it opens.

Setup: Windsurf

Add the following to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "vaquill": {
      "command": "uvx",
      "args": ["vaquill-mcp"],
      "env": {
        "VAQUILL_API_KEY": "vq_key_your_key_here"
      }
    }
  }
}

Real Workflows: How Lawyers and Researchers Use This

Once the MCP server is connected, you just talk to Claude normally. It figures out which tools to call on its own.

Here are the workflows I see people use most, modeled on actual lawyer research patterns.

Workflow 1: Researching a Statutory Scheme

You're advising on OSHA injury recordkeeping and need to know what the rule actually requires, where the duty sits, and which employers it exempts.

You type:

What does the CFR require for OSHA injury and illness recordkeeping? Pull the operative sections, not a summary.

Claude calls search_us_statutes with corpusType: "CFR" and gets back ranked sections with citations and official source links. It then calls get_us_statute_section_text on the ones that matter and quotes the published language rather than paraphrasing it.

Follow up:

The section you quoted refers to "recordable injury" without defining it. Get me the sections around it.

Claude calls get_section_neighbors. The definitions turn up a few sections back and the partial exemptions a few forward, in statutory order, without crossing out of the part. This is the step that separates reading a rule from reading a rule correctly.

Then, if you want the whole thing:

Enumerate every section in that part, in order.

Claude calls list_statute_divisions with the corpus, title, and part, and walks the level below it. You get the part's table of contents, in statutory order, rather than whatever a relevance ranking happened to surface.

Workflow 2: Is It Still Good Law?

You're about to quote a state regulation in an advice memo. Before you do, you need to know how current the text in front of you actually is.

A statutes corpus answers that question differently than a case-law database does. There is no treatment history to check. What there is, is provenance and a clock.

You type:

Before I rely on this, how fresh is your Washington state regulations data, and where did this text come from?

Claude calls list_statutes_coverage. For each jurisdiction and corpus pair it returns when we last pulled that body of law from its publisher, the cadence we pull it on, and whether that is current, stale, failing, or never_retrieved. It also flags pairs that are paused (complete and queryable, no longer refreshed) or retired.

The get_us_statute_section_text response carries the other half: a sourceUrl pointing at the government page that published the text. That is the link you verify against.

This single check is the difference between a credible memo and a sanctions exposure.

We cover that risk in detail in our piece on AI hallucinations and legal research sanctions.

Workflow 3: Statute Lookup

You're advising on a civil rights claim and want the text of the statute plus the standard of review for a related agency action.

You type:

Pull 42 U.S.C. 1983 for me, then show me 5 U.S.C. 706 on the scope of APA review.

Claude calls resolve_statute_citation on each Bluebook string, which confirms the citation against the corpus and returns the exact section it names. It then calls get_us_statute_section_text for each. You get the operative language of the civil rights cause of action and the APA review standard, both as published, both with a link to the government source.

Then:

Give me 17 U.S.C. 107 broken out by subsection, so I can cite the four factors individually.

Claude calls the text tool with structured=true. Alongside the HTML and plain text you get a subsection tree, where each node carries its pincite path and its full pinpoint citation. Quoting factor three becomes addressing a node, not hunting through a wall of text and hand-building the cite.

Other provisions you'll reach for the same way: 28 U.S.C. 1331 (federal-question jurisdiction), 18 U.S.C. 922 (firearms), and 16 C.F.R. 444.1 (the FTC credit practices definitions).

Workflow 4: Writing a Legal Memo

You need a three-state survey memo on non-compete enforceability, and you want every proposition tied to a statute you can open.

You type:

Search California, Texas, and New York statutes for non-compete and restrictive covenant provisions. Give me the sections, then the text of the ones that state the rule.

Claude calls search_us_statutes with corpusType: "STATE" and a list of states, which returns ranked sections from all three codes in one call. It then calls get_sections_batch to enrich the whole result page in a single round trip, and get_us_statute_section_text on the handful that carry the operative rule.

You can then say:

Now draft the memo. Structure it as an introduction, the rule in each state, where they diverge, and a conclusion. Cite the section for every proposition and include the official source link.

Claude produces a structured memo where every assertion is backed by a section it actually retrieved, with the government URL attached.

Workflow 5: Quick Citation Lookup

Someone sends you a draft with three statutory cites in it, and one of them was produced by an LLM. You need to know which.

You type:

Check these three: 42 U.S.C. 1983, 16 C.F.R. 444.1, and 15 U.S.C. 7291. Which of them actually resolve?

Claude calls resolve_statute_citation on each. A real citation comes back with resolved: true and the full section metadata attached. A citation that names nothing comes back with resolved: false and a null section, which is a confident negative rather than a plausible-looking guess. That distinction is the whole reason the tool exists, and it is charged either way for exactly that reason.

Ten seconds, no browser tabs, and a definite answer on a cite you were about to file.

Workflow 6: Watching a Rule for Changes

You advise a client whose whole compliance posture rests on one part of the CFR. You do not want to re-read it monthly. You want to be told.

You type:

What sources can I subscribe to for FDA regulations, and how often are they refreshed?

Claude calls list_boards and returns the watchable boards with their cadence, their last successful retrieval, and whether we're still polling them.

Then:

Watch 21 CFR part 314 and post to my webhook at https://example.com/hooks/vaquill. Sign it, then send a test.

Claude calls create_watch with the board, a scope narrowed to that title and part, your webhook URL, and a signing secret. The URL is checked against an SSRF blocklist before it's accepted. Then test_watch fires a one-off delivery, tagged as a test event, so you can confirm your handler works before anything real depends on it.

Weeks later:

Anything change on that watch? Show me the actual edit.

Claude calls list_watch_changes and gets the specific sections that were added, amended, or removed, with citations. Then get_watch_change_diff on the one you care about, which returns the section's text before and after. If your endpoint went quiet, list_watch_deliveries shows the attempts and what they returned.

Tips for Getting the Best Results

A few things I've learned from using this daily:

Name the jurisdiction and the corpus. "Texas Penal Code sections on theft" produces much better results than "state law on stealing." The corpus filters are the difference between searching 4M sections and searching the right few thousand.

Ask for the text, not a summary. If you say "what does this section say", a model will happily paraphrase from memory. Say "pull the text" or "quote it" and it reaches for the tool. The tool is the whole point.

Chain the lookup. Resolve the citation, pull the text, then pull the neighbors. Three calls, and you have the provision with its definitions and its exceptions instead of a paragraph floating in space.

Verify against the source URL, not against us. Every text response carries the government page it came from. Open it before you file. Our freshness data tells you when we last checked; the publisher tells you what the law is.

Use the free tools to orient first. list_statutes_coverage and list_statutes_laws cost nothing and answer "is this jurisdiction even in here, and how current is it" before you spend anything searching it.

Don't ask it for case law. It does not have any. If you ask "what cases interpret this section", a model with no case-law tool will answer from training data, and that is exactly the failure mode you connected an MCP server to avoid. Attach a case-law connector and say which one to use.

FAQ

Can Claude do legal research? Yes, but not reliably on its own. On its own Claude reasons well and hallucinates citations, because it has no live legal database. Connect a legal research MCP server and Claude reads real statutory text and returns citations you can open and verify.

What is an MCP connector for legal research? MCP (Model Context Protocol) is an open standard Anthropic released in late 2024 that lets Claude call external tools. A legal research MCP connector exposes tools like statute search, citation resolution, and full-text retrieval to Claude so it queries a real database instead of guessing. See the spec.

How do I connect Claude to a legal research database? Two ways. Add a connector from Claude's built-in directory (Customize then Connectors then Browse Connectors), which Anthropic expanded for legal on May 12, 2026. Or wire in a self-hosted MCP server with a short JSON config that works across Claude Desktop, Claude Code, Cursor, VS Code, and Windsurf. This guide shows the config for both desktop and terminal.

What tools does the Vaquill AI MCP server actually expose? Nineteen. Ten read the corpus: search_us_statutes, resolve_statute_citation, get_us_statute_section, get_us_statute_section_text, get_section_neighbors, get_sections_batch, list_statute_divisions, list_statutes_laws, list_statutes_coverage, and get_pricing. Nine manage change monitoring: list_boards, create_watch, list_watches, update_watch, delete_watch, list_watch_changes, get_watch_change_diff, list_watch_deliveries, and test_watch. The set is generated from the live API spec at startup, so it tracks the API rather than the package version.

Does it search case law? No. It is statutes, regulations, and codes. There is no case-law search, no citation network, no treatment history, and no ask-anything endpoint on this server. For US opinions, run the CourtListener connector alongside it; the two coexist fine in one config and Claude routes between them.

Can it tell me when a regulation changes? Yes, and that is the part case-law connectors do not have. Subscribe to a source with create_watch, narrow it to one title, part, or section, and get a webhook or email when it changes. list_watch_changes tells you which sections moved and get_watch_change_diff shows the before and after text.

Is Claude for Legal a real product? Yes. Anthropic launched Claude for the legal industry on May 12, 2026 with more than 20 MCP connectors and 12 practice-area plugins (Anthropic, May 2026). Legal research is one of the headline use cases.

Does Claude have access to Westlaw or case law by default? No. Out of the box Claude has no access to Westlaw, Lexis, or court opinions. Access comes from a connector. Thomson Reuters connects CoCounsel Legal (Westlaw and Practical Law) to Claude, announced May 12, 2026 (LawSites, May 12, 2026).

Will Claude still hallucinate citations with an MCP connected? The risk drops sharply for anything inside the corpus, because the answer is retrieved text with a government URL attached. It does not drop for anything outside the corpus. Ask this server for case law and the model has no tool to call, so it falls back on training data. Scope your questions to what the connected servers actually cover.

Is it free to use Claude for legal research? Claude itself needs a paid plan for serious work. The MCP server may be free or metered depending on the provider. Vaquill AI is self-serve; sign up to start, and current pricing is shown in your dashboard. Coverage, catalog, pricing, and all nine watch tools cost no credits.

Is the CourtListener connector free inside Claude? Yes. Free Law Project made CourtListener available in Claude's directory on May 12, 2026, and every CourtListener account includes free API access; elevated access is available through an FLP membership (LawSites, May 2026).

Does CoCounsel Legal require a paid subscription? Yes. The CoCounsel Legal connector brings Thomson Reuters data (roughly 1.9 billion Westlaw and Practical Law documents) into Claude, but you need an existing Thomson Reuters subscription to use it; pricing is quote-based, not public (LawSites, May 2026).

Which AI clients support legal research MCP servers? Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), and Windsurf all support MCP, so the same legal research server works in any of them with a per-client config.

For Developers

If you're building a legal tech product or an AI agent that needs primary law programmatically, this MCP server is a thin wrapper over the same REST API you'd call directly. Every tool maps to one endpoint, and the mapping is derived from the published spec rather than maintained by hand.

For a deeper look at agent architectures, multi-step tool chaining patterns, and integration with frameworks like LangGraph and CrewAI, see our post on adding legal research to AI agents with MCP.

The public REST API and the MCP server cover statutes, regulations and codes: the U.S. Code, the CFR, 52 state and territory codes, constitutions, court rules, state regulations, the Federal Register, agency guidance, and Executive Orders, plus the change-monitoring layer. Case-law search and the AI Q&A surface are features of the Vaquill AI app, not REST or MCP endpoints. To get started, sign up at app.vaquill.ai or email contact@vaquill.ai.

You don't need to build your own RAG pipeline to use them.

Priyansh Khodiyar

Co-Founder & CTO

Priyansh leads engineering and AI at Vaquill, from the matter workbench to drafting, document comparison, document matrix, and citation-verified research.