Make a Model Context Protcol (MCP) server for Case Law API

[NamedIdentity]

IDEA:
Anthropic made the Model Context Protocol, releasing it around Nov 2024, which allows easily connecting AI LLMs to data sources and tools. It's been gaining traction. Google just announced they'll be integrating it into Gemini, with Open AI pledging the same weeks earlier. (https://techcrunch.com/2025/04/09/google-says-itll-embrace-anthropics-standard-for-connecting-ai-models-to-data/)

I think it's time for the free law project to make an MCP server to connect your case law API to AI LLMs like Gemini.

Rationale:
I think once frontier LLM models have direct access to comprehensive case law databases, the subscription costs of professional case law platforms will be much harder to sell. The value of the Free Law Project would become more apparent, and upon experiencing the benefits of being able to use their preferred frontier model with FLP's case law database, people (nonprofits, legal professionals, citizens) might see now as the opportune time to provide more resources and support to the FLP so that developments in AI can be fully leveraged to our collective benefit.

I think it's just a matter of time until people start building their own personal AI agents by uploading the databases, text books, and other sources of information relevant to their work to Google Drive, with Gemini then treating the folder designated as a knowledgebase as one giant repository. Eventually that repository will not just be files you upload, but the data you generate while using the AI agent. People will build their experts by adding databases, tools, and giving them direct instruction through discussing and exploring subjects and materials. I gather one already can do many of these things using Drive and Google Cloud; that the free law project's case law database could be uploaded to Drive and turned into a RAG database using Google Cloud that Gemini can utilize via Gemini API.

Gemini 2.5 Pro Deep Research (released yesterday) is very impressive and useful. Can you imagine how amazing it would be to connect it to a case law database optimized for AI LLMs? That's the future I see coming, and it doesn't have to cost $700 a month.

[mlissner]

This is cool. Two quick thoughts: I assume organizations that are making their databases available aren't doing so for free (or at least they aren't always doing so for free). Is there a method here for compensating databases that are utilized?

@rachlllg, have you been following this and do you have thoughts?

[NamedIdentity]

My understanding of how MCPs and paid-for services through MCP servers is limited. But I think the answer to your questions is that payment for database utilization is billed/managed through the API keys a company generates to let people access their services.

I'm above average in terms of my competence to understand and use computer systems (I can root android, mod games, build a PC, manage file systems, manage codecs, NLEs, and hard-drive RAID arrays to optimize high frame-rate video capture and encoding back when doing that was very difficult (2012), etc), but never learned to do more technically demanding tasks, like coding or web development. What I would want to use MCP servers to do, I don't have the skills to achieve. So I haven't invested my time in tinkering with MCPs servers directly, beyond one initial trial run to evaluate the viability of trying to do things myself.

My knowledge of MCPs is mostly from observing what people are doing with them. Which is mostly using MCPs with services I'm unfamiliar with or never used. Though, when I was doing my evaluation I noticed the most popular internet search MCP server was Brave search. I learned you need an API key to use it, and reading the Brave search website they have paid tiers which one would need in order to 'really' make use of AI-MCP based internet search. I'm unclear on how one use's their own private API key on an MCP server someone else set up and keeps running; assuming that's even how that works.

[rachlllg]

Ah yes, things are moving so fast, it's hard to keep up.

Here are some resources:

• https://www.anthropic.com/news/model-context-protocol
• https://modelcontextprotocol.io
• https://github.com/modelcontextprotocol

Essentially, LLMs have knowledge limitations and MCP allows you to give model access to tools or resources that expands their capabilities. An example is you can give Claude access to your GitHub account and ask it to summarize the last 5 commits in natural language. You can also ask it to perform actions for you, like you can give Claude access to your gmail and ask it to move all emails from folder A to folder B, through natural language. We control how much access the model can have, read vs write etc, and the access is passed through an authorization token, or API key.

An example use case for us is: a user asks the model to summarize an opinion, in the backend, it retrieves the opinion using the user's API key, and the model uses the retrieved opinion to create a natural language summary. The user should be able to utilize MCP directly on their end using API key (that being said, I tried to set this up on my Claude Desktop and haven't been able to, which I suspect is a path issue which I'm still working through).

• https://www.elastic.co/search-labs/blog/model-context-protocol-elasticsearch
• https://github.com/elastic/mcp-server-elasticsearch

This can also be done for replication through PostgreSQL, I'm curious if any of our replication users already implemented MCP on their replicated database.

• https://github.com/modelcontextprotocol/servers/tree/main/src/postgres

A lot of these are done through Claude Desktop app right now, since Anthropic is the one that started this, but many other LLMs are also catching the wave.

• https://modelcontextprotocol.io/clients

[rachlllg]

Finally, to add on re: MCP for case law API, the access is controlled by the API key, so users can utilize it similar to how they utilize our API currently.

We are not giving our data to be used as a public knowledge base or be used to expand LLMs case law knowledge that's exposed to the public, the knowledge is only utilized in the specific user instance, kind of like building a RAG on top of the LLM (+ it can also utilize tools to perform actions - agentic). These are functionalities that are already available in LLMs, MCP provides a standard language to integrate them.

Here is how we can create this MCP server for case law API, we can define / limit the functions the LLMs can perform, users can add the MCP to their local instance of LLMs to assist their research.

Unless we integrate the LLM to courtlistener like a chatbot, I think it might be hard for an average web user to add the MCP to their own instance of LLM as it does require some coding knowledge.

[mlissner]

Thanks, that's helpful. I think I'll monitor this before we make a big commitment to it, but if somebody winds up prototyping it, that'd be interesting to see too.

[rlfordon]

Maybe I should have added this as a comment here, but I created another discussion (#89) about creating a CustomGPT where someone could put in their API key. It seems like a similar idea to this one, but the CustomGPT would be less powerful, but perhaps easier to build and more accessible to people without coding knowledge.

[mlissner]

Another request for this just posted yesterday:

freelawproject/courtlistener#6057

It notes that there are three unofficial CourtListener MCP servers now:

• https://github.com/open-legal-tools/courtlistener-mcp
• https://github.com/Travis-Prall/court-listener-mcp
• https://github.com/UPSD1/courtlistener-mcp

I haven't checked them out at all, but

[NamedIdentity]

I posted about the Open-Legal-Tools project earlier in July (#93).

Pertinent to reiterate here one point from that post:

"Google updated the MCP toolbox to let AI Agents better access databases. This seems like it could let a more direct and efficient interface between AI LLMs and the CourtListener database.

https://www.marktechpost.com/2025/07/07/google-ai-just-open-sourced-a-mcp-toolbox-to-let-ai-agents-query-databases-safely-and-efficiently/"

[cyclic-elevator]

In case folks are curious, I took an AI agent (gemini-pro) to analyze the genai-toolbox code repo with these prompts:

Thoroughly Analyze both the docs and the code in this repo, and report:

• the design goals of the project
• the high level functionalities as currently implemented
• the use cases it is intended to support
• potential use cases based on undocumented capabilities
• potential use cases based on future extensions
• the likely future roadmap

and received the following response.

[cyclic-elevator]

I agree that the AI tools market is evolving at an incredible pace. We're seeing new capabilities and applications emerge constantly. This rapid evolution means that even the major players in the AI-legal space, like Harvey, Westlaw, and Casetext, will likely need to adapt and evolve their product offerings continuously. As the underlying AI models become more powerful and AI-assisted workflows become more refined, the legal tech landscape will continue to shift.

It's also worth noting that many general-purpose AI tools can be adapted for ad-hoc legal workflows with relatively minor adjustments. This flexibility lowers the barrier to entry for legal tech innovation and opens up many possibilities.

In this context, a CourtListener MCP server could be a very strategic move. While its shelf life might be limited as the market matures, its immediate value would be in significantly increasing the exposure and usage of the CourtListener API. By making it easier for developers and researchers to experiment with AI-legal workflows, it could foster a vibrant ecosystem of innovation around CourtListener's data and services.

[mlissner]

Looks like another MCP is probably here: https://github.com/beshkenadze/us-legal-tools (I haven't checked it out yet.)

[cyclic-elevator]

Thanks for sharing this!

This repo looks much more serious than the others:

• the courtlistener-sdk has 25 commits excluding the bots
• the author had implemented cursor based pagination!
• the author is using cursor for development
• there is substantial CI flow investment

[beshkenadze]

Hey! I’m the author of https://github.com/beshkenadze/us-legal-tools and https://github.com/beshkenadze/eyecite-js.

Both projects are under active development, so I wouldn’t consider them production-ready yet due to ongoing changes in their architecture.

Also, because some of the APIs lack proper OpenAPI v3 documentation, there may be occasional inaccuracies in how the official APIs have been translated into OpenAPI v3.

Feel free to reach out if you have any questions about the projects!

[mlissner]

Got one more request for this today in my call with https://github.com/freelawproject/crm/issues/932

[anseljh]

Found an MCP server for Brazilian law among the list of community MCP servers.

[mlissner]

And another MCP implementation is here: https://github.com/khizar-anjum/courtlistener-mcp

We better get on this. :)

[whazziz]

Was just researching if these exist. I think that pare ships with other Legal Tech firms (like Everlaw, where I work) could help 1) expand your footprint and 2) augment existing tooling (Ai or others)

[khizar-anjum]

Thank you @mlissner for the shoutout. This is still a very young project and I have deployed it on smithery where people can directly interact with it and explore its capabilities. https://smithery.ai/server/@khizar-anjum/courtlistener-mcp

I would appreciate feedback from the community as that would help me gauge what the community wants and needs and build accordingly. So please, feel free to open a PR, suggest what functionalities would be great and help the community.

[mlissner]

Another request today.

[mlissner]

We have begun designing our MCP. If anybody here has any input they'd like to share as we do this (things we might not think of or lessons learned), please chime in! We'll be posting a contract position to build this for CL once we've got the design figured out.

[NamedIdentity]

Actually, I have an email I drafted last week which I was going to send to FLP on Monday. I developed a courtlistener-mcp MCP server and have it up and running in OpenCode CLI as a local MCP server. You can use the repo as a foundation to develop an official FLP MCP if you want.

https://github.com/DefendTheDisabled/courtlistener-mcp

You could list me as a contributor or something. idk.

It wasn't that hard to build. Took an afternoon. Room for improvement.

A growing concern with MCP servers is they are eating up context windows; I think that should be part of a thoughtfully designed courtlistener MCP; low overhead on context windows.

I'll send that email to Mike and Jessica now.

[NamedIdentity]

Also, I think design of a CourtListener MCP might want to consider future proofing by focusing not on designing an MCP server for 'everyone', but in consolidating all relevant documentation, keeping that documentation up to date and publicly exposed to AI agents, and creating an Agent Skill.

Agent Skills have a skill.md file and references folder you can stuff all needed documentation into. In references you can supply multiple schemas/blueprints for different types of MCP server design. The skill can instruct the llm how to work with the user to define what types of features/functions they want or need from a courtlistener MCP server.

That way AI agents can create MCP servers optimized to user needs and FLP can focus on creating systems and updating documentation rather than managing an MCP server repo. For people that don't need or want a customized implementation, you can define a 'general needs' schema/blueprint you offer for people to easily get up and running and supply that via your CourtListener website.

The benefit of creating a skill like this is as you update documentation, the MCP server automatically gets updated with new features which distribute to all users no matter how customized their implementation is.

I think of project SPECs and agent skills like how DNA assembles into a complex organism.

There have been multiple developments in MCP server design to make them more effective which probably should be researched; tool search instead of listing all tools and having agents interact with MCP servers via code instead of natural language.

I think defining ways to optimize the MCP server so it's effective but efficient is the real value that developers can offer. Getting something 'working' I was able to do as a non-developer in an afternoon. It wasn't easy, and I"m not unskilled, but I'm a far cry from someone who reads and writes code and has years of experience in software engineering.

[anya2975]

Hi, chiming in with my experience trying to use one of the hobby project court listener MCPs for a client I am working with. They do eat A LOT of tokens and a model may make multiple calls to each tool. I'm doing it in Azure Foundry and am dealing with rate limits and timeouts when asking anything that is not a direct query for a particular case. I'm nowhere close the API rate limit.
It may be worth exploring organizing tools by the question type rather than the API endpoint, as my model seems to be enthusiastic about calling the tools many times.

[anseljh]

People in law firms and in-house teams would appreciate instructions on how to use a CL MCP with Microsoft Copilot, which many of those folks have (and may be limited to). Consider having technical and non-technical docs. Technical to help the IT team implement, and addressing usual security type concerns. Non-technical to explain to the legal folks why they should care, how to ask IT to set it up, and how to use it once it is set up.

See, e.g., this article on using MCP with the Copilot Studio agent builder.

This is likely to be a pain in the you-know-what, so I wouldn't prioritize it for initial launch!

[john-walkoe]

Adding lessons learned from a CourtListener MCP I'm currently building (not released yet) focused specifically on citation validation and hallucination detection, and several USPTO MCPs, that are directly relevant to the design conversation here.

I presented on MCP in legal practice at an ILTA webinar late last year, including a live demo of a citation validator built on @blakeox's courtlistener-mcp and a 100+ page guide on setting up MCP servers in legal environments, so this is something I've thought about at length. I built on prior community work from @JamesANZ and @blakeox, whose repos were valuable source material. I reduced the tools count to 6 and use docstrings and return responses to guide the LLM to the same workflow without a lengthy system prompt. 6 focused tools vs the 33 in the original, which matters when every token of system prompt is competing with your context window. My implementation isn't public yet but will be released soon.

---

Microsoft CoPilot Studio requires Streamable HTTP, not STDIO

@anseljh is right that this is painful. CoPilot Studio only connects to MCP servers over HTTPS with the Streamable HTTP transport. It cannot talk to a locally-running STDIO process the way Claude Desktop can. This means you need a publicly-reachable web server: Docker plus a public URL, a cloud deployment, an MCP gateway, or an MCP proxy. Dev tunnels (VS Code tunnels, ngrok, etc.) can expose a local server publicly, but managing one tunnel per user is operationally complex and fragile, and introduces real security concerns. Each tunnel is a publicly-reachable endpoint exposing access to a user's CourtListener API key and potentially their local environment, with no enterprise auth layer, audit logging, or centralized revocation. Not realistic, and not acceptable, for a law firm. An MCP gateway (such as Cloudflare's, or self-hosted via LiteLLM Proxy which has a full MCP gateway) is the cleanest enterprise path. It handles HTTPS termination, manages MCP access by Key, Team, and Organization (directly solving the per-user API key problem), bridges all three transports so a STDIO server can be exposed to CoPilot over Streamable HTTP without rewriting it, and provides the audit logging that dev tunnels lack entirely. The catch is that properly documenting a CourtListener MCP deployment then stops being about how to use the MCP and becomes a guide on how to set up and operate an MCP gateway, a meaningfully different and more complex problem that will be out of reach for most legal teams without dedicated IT support. It should be a first-class design consideration from day one, not an afterthought.

---

The citation-lookup throttle makes shared multi-tenant deployments impractical

This is the bigger structural issue. The citation-lookup API has an additional throttle of 60 valid citations per minute per API key, and CourtListener API keys are issued for individual use. In a firm deploying a shared MCP endpoint used by 20 attorneys, all requests share one key and one rate limit, which collapses immediately under any real workload. The only architecturally sound workaround is one API key per user, each routed through their own server instance. With dev tunnels that means one tunnel per user, and with an MCP gateway it means per-user key injection configured at the gateway level. Either way, genuinely out of reach for non-technical deployments and arguably defeats the point of a shared enterprise tool. Any official FLP MCP design should address this explicitly, either per-user key auth at a gateway level, or clear documentation that citation-lookup at scale requires individual deployments.

---

Context window flooding is real, and progressive disclosure with API-level field filtering is the answer

@anya2975 is exactly right that agents will enthusiastically call tools multiple times and pile up results. The pattern that works is progressive disclosure: return minimal identifying fields in search results, then let the agent request full detail on a specific record only when needed.

My USPTO Patent File Wrapper MCP does this with configurable field tiers enforced at the API request level, not post-processing:

• Minimal (~15 fields, 95-99% context reduction) - discovery: application number, title, status, filing date
• Balanced (~18 fields, 85-95% reduction) - analysis: adds assignee, continuity chain, examiner
• Complete (50+ fields) - only when deep investigation is needed
• Ultra-minimal (2-3 custom fields) - specific workflows at 99% reduction

Certain heavy fields like documentBag are explicitly excluded from all tiers with a config-level warning (# WARNING: Can cause 100x token increase), with agents guided to targeted retrieval tools instead. Every search response includes a query_info block with the search_tier used and a recommended_workflow map showing what tool to call next, so the agent always knows the progressive path without guessing.

For citation validation specifically, this matters because a brief can contain dozens of citations and each get_cluster call for verification adds to the context load. Our implementation returns only the fields needed to confirm or refute a citation at each step, preserving context headroom for the analysis and report generation phase where it's actually needed.

Happy to share more once we release, and happy to answer questions in the meantime.

[khizar-anjum]

+1 The biggest resource to optimize for in an MCP server is the context. This means that we cannot go by the API standard of returning everything that matches the request. The results for each tool call need to be informative enough so the model can move forward but precise enough that it does not overfill the context window. @john-walkoe points out the right strategy here of API-level field filtering.

On the subject of hosting the MCP server, Smithery is one option to consider. They function as a registry and discovery platform for MCPs and stay current with the MCP specification. Users can connect their favorite MCP-compatible client to deployed servers without FLP needing extensive DevOps configuration. However, Smithery's free hosting tier has been discontinued, so this would require a paid plan. If the MCP server requires API key management, such as CourtListener API key, that would fall on the end user. That is what I did when I hosted my MCP server on Smithery.

[mlissner]

A thought from an FLP board member, @nadahlberg:

Clear usage communication. The MCP should be able to tell a user "you've used 80% of your monthly allowance" or "upgrade your membership for more access" — not just fail silently. This is both good UX and good for bringing in new members/higher tiers.

[anseljh]

This wasn't my comment, but I like it and here are my additional $0.02: At least on the $20 Pro tier I have, Claude Code does this when you get up toward its periodic usage limits. It is quite nice and a good pattern to emulate. Just sharing in case you haven't seen it. Sorry, I couldn't find a screenshot, but I'm sure I'll be able to take one before too long!

[anseljh]

Here we go:

[john-walkoe]

Following up on my earlier comment — the CourtListener citation validation MCP I mentioned is now public:

https://github.com/john-walkoe/courtlistener_citations_mcp

It's focused specifically on citation validation and hallucination detection rather than general case law search. The Mata v. Avianca brief (the canonical AI hallucination case) was used as the primary test — the demo video on the README shows it in action.

A few things that came out of building it that may be relevant to FLP's design:

• Name mismatch detection turned out to be the most important feature — catching citations where the reporter number is real but resolves to a completely different case than what the document claims (e.g. "eBay v. MercExchange, 646 F.3d 869" actually resolves to TiVo v. EchoStar). This is the hardest hallucination to catch manually and the most dangerous in practice.
• eyecite first — running a local eyecite pass before any API call gives a full census of all citation types (case, statutory, id., supra) for free, with no rate limit hit. Useful for scoping before committing API quota. This ended up as a dedicated tool (extract_citations), pushing the count to 7 vs the 6 I had originally written — the local-only step warranted its own tool given it has no API dependency, no rate limit, and runs instantly.
• MCP App panel — using FastMCP's MCP Apps feature to render an interactive color-coded results panel inline in Claude Desktop (requires Docker/HTTP mode).

Also submitted to the Docker MCP Catalog today (PR #1517 pending review), which would make it one-command deployable for firms already running Docker Desktop.

On @nadahlberg's usage communication point — fully agree. Silent throttle failures are particularly confusing with citation-lookup since the limit counts valid citations, not requests. A brief with 60 real cases burns the entire minute's quota in one call, with no feedback to the user about why it paused.

It's MIT licensed — FLP is welcome to use it or any parts of it as reference or foundation for the MCP you're designing. If it does inform the work, a mention would be appreciated but not required. Happy to answer questions or share anything that might be useful for FLP's design.