AI Agent for Legal Research: Case Law Search, Citation Extraction, and Analysis

The Problem with Manual Legal Research

Legal research is one of the most time-intensive tasks in legal practice. Associates spend an average of 10 to 15 hours per week searching case law databases, reading opinions, extracting relevant citations, and synthesizing findings into memos. An AI agent can dramatically accelerate this workflow by searching databases, parsing citations, ranking relevance, and drafting initial memos for attorney review.

System Architecture

The legal research agent consists of four tools:

1. Case Law Search — query legal databases and retrieve matching cases
2. Citation Extractor — parse legal citations from case text
3. Relevance Ranker — score and rank cases by relevance to the research question
4. Memo Generator — synthesize findings into a structured research memo

Step 1: Case Law Search Tool

We build a search tool that interfaces with legal databases. In production you would connect to services like CourtListener, Casetext, or Westlaw APIs. Here we use CourtListener's free API.

import httpx
from pydantic import BaseModel


class CaseResult(BaseModel):
    case_name: str
    citation: str
    court: str
    date_filed: str
    snippet: str
    url: str


class SearchResults(BaseModel):
    query: str
    total_hits: int
    cases: list[CaseResult]


async def search_case_law(
    query: str, jurisdiction: str = "", max_results: int = 20
) -> SearchResults:
    """Search CourtListener for relevant case law."""
    params = {
        "q": query,
        "type": "o",  # opinions
        "order_by": "score desc",
        "page_size": max_results,
    }
    if jurisdiction:
        params["court"] = jurisdiction

    async with httpx.AsyncClient() as client:
        resp = await client.get(
            "https://www.courtlistener.com/api/rest/v4/search/",
            params=params,
            headers={"Authorization": "Token YOUR_API_KEY"},
        )
        resp.raise_for_status()
        data = resp.json()

    cases = []
    for result in data.get("results", []):
        cases.append(
            CaseResult(
                case_name=result.get("caseName", "Unknown"),
                citation=result.get("citation", ["N/A"])[0]
                if result.get("citation")
                else "N/A",
                court=result.get("court", "Unknown"),
                date_filed=result.get("dateFiled", "Unknown"),
                snippet=result.get("snippet", "")[:500],
                url=result.get("absolute_url", ""),
            )
        )

    return SearchResults(
        query=query, total_hits=data.get("count", 0), cases=cases
    )

Step 2: Citation Extraction

Legal citations follow specific patterns like 123 U.S. 456 (1901) or 456 F.3d 789 (2d Cir. 2006). We use regex combined with an LLM for ambiguous references.

import re


CITATION_PATTERNS = [
    # Federal reporters: 123 U.S. 456
    r"\d+\s+U\.S\.\s+\d+",
    # Federal supplement/reporter: 123 F.3d 456
    r"\d+\s+F\.(?:2d|3d|4th|Supp\.(?:\s*2d|\s*3d)?)\s+\d+",
    # State reporters
    r"\d+\s+[A-Z][a-z]+\.(?:\s*(?:2d|3d|4th))?\s+\d+",
    # Parallel citations in parentheses
    r"\(\d{4}\)",
]


def extract_citations(text: str) -> list[dict]:
    """Extract legal citations from case text using regex."""
    citations = []
    seen = set()

    for pattern in CITATION_PATTERNS:
        for match in re.finditer(pattern, text):
            citation_text = match.group().strip()
            if citation_text not in seen:
                seen.add(citation_text)
                start = max(0, match.start() - 100)
                end = min(len(text), match.end() + 100)
                citations.append(
                    {
                        "citation": citation_text,
                        "context": text[start:end].strip(),
                        "position": match.start(),
                    }
                )

    return citations

Step 3: Relevance Ranking with an LLM

Raw search results need ranking by how well they support the research question. The LLM evaluates each case against the query and assigns a relevance score.

from openai import OpenAI

client = OpenAI()


class RankedCase(BaseModel):
    case_name: str
    citation: str
    relevance_score: float  # 0.0 to 1.0
    key_holding: str
    applicable_reasoning: str


class RankedResults(BaseModel):
    ranked_cases: list[RankedCase]


def rank_cases(
    research_question: str, cases: list[CaseResult]
) -> RankedResults:
    """Rank cases by relevance to the research question."""
    cases_text = "\n\n".join(
        f"Case: {c.case_name}\nCitation: {c.citation}\n"
        f"Court: {c.court}\nDate: {c.date_filed}\n"
        f"Snippet: {c.snippet}"
        for c in cases
    )

    response = client.beta.chat.completions.parse(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a legal research assistant. Score each case "
                    "from 0.0 to 1.0 for relevance to the research "
                    "question. Extract the key holding and explain why "
                    "the reasoning applies."
                ),
            },
            {
                "role": "user",
                "content": (
                    f"Research Question: {research_question}\n\n"
                    f"Cases:\n{cases_text}"
                ),
            },
        ],
        response_format=RankedResults,
    )
    result = response.choices[0].message.parsed
    result.ranked_cases.sort(
        key=lambda x: x.relevance_score, reverse=True
    )
    return result

Step 4: Research Memo Generation

The agent compiles everything into a structured legal research memo.

def generate_memo(
    question: str, ranked: RankedResults, max_cases: int = 5
) -> str:
    """Generate a legal research memo from ranked cases."""
    top_cases = ranked.ranked_cases[:max_cases]
    case_summaries = "\n\n".join(
        f"**{c.case_name}** ({c.citation}) "
        f"[Relevance: {c.relevance_score:.0%}]\n"
        f"Holding: {c.key_holding}\n"
        f"Application: {c.applicable_reasoning}"
        for c in top_cases
    )

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "Write a legal research memo in IRAC format "
                    "(Issue, Rule, Application, Conclusion). "
                    "Cite all cases properly. Be thorough but concise."
                ),
            },
            {
                "role": "user",
                "content": (
                    f"Issue: {question}\n\n"
                    f"Relevant Cases:\n{case_summaries}"
                ),
            },
        ],
    )
    return response.choices[0].message.content

Running the Full Pipeline

import asyncio


async def legal_research(question: str) -> str:
    """Run the full legal research pipeline."""
    results = await search_case_law(question)
    ranked = rank_cases(question, results.cases)
    memo = generate_memo(question, ranked)
    return memo


memo = asyncio.run(
    legal_research(
        "Can an employer enforce a non-compete clause against "
        "an employee who was terminated without cause?"
    )
)
print(memo)

FAQ

Which legal databases offer APIs suitable for AI agents?

CourtListener provides a free API with access to millions of federal and state court opinions. Commercial options include Casetext (now part of Thomson Reuters), Westlaw Edge API, and LexisNexis API. Each has different coverage, rate limits, and pricing models.

How do you prevent the agent from hallucinating case citations?

Always ground the memo in actual search results rather than asking the LLM to recall cases from its training data. Cross-reference every citation against the database to verify it exists. Include a validation step that checks citation format and confirms the case name matches the reporter reference.

Is AI-generated legal research admissible in court filings?

AI-generated research is a tool for attorneys, not a substitute for professional judgment. Attorneys remain responsible for verifying all citations and analysis before including them in filings. Several courts have implemented rules requiring disclosure of AI usage in brief preparation.

---

#LegalResearch #CaseLaw #CitationExtraction #NLP #AIAgent #AgenticAI #LearnAI #AIEngineering