Skip to main content
openai tutorialOpenAI tutorial

Tutorial 07: MCP Integrations for Legal Workflows (OpenAI)

Connect ChatGPT to case law databases, document management systems, and court records for seamless legal research workflows using the Model Context Protocol.

What You'll Learn

This tutorial shows you how to connect ChatGPT to legal data sources—case law, document management, court records—so you can research and verify citations without leaving ChatGPT.

Learning Objectives

By the end of this tutorial, you will:

  • Understand the Model Context Protocol (MCP) and its legal applications
  • Set up Midpage for case law research integration
  • Connect to document management systems (iManage, Clio, SharePoint)
  • Build custom legal research workflows with MCP
  • Execute statutory research workflows with version tracking
  • Implement automated citation verification processes
  • Set up court records alerts and docket monitoring
  • Apply agentic multi-step research patterns
  • Interpret case law analytics for strategic insights

Advanced Level | Some Technical Comfort Required | Time: ~2 hours (estimated)


What Is MCP?

Model Context Protocol (MCP) is an open standard for connecting AI to external tools and data sources. Think of it as USB for AI—a universal connector. OpenAI supports MCP in ChatGPT via apps (formerly connectors) and Developer Mode. Full MCP (including write actions) is available to Business and Enterprise/Edu plans; Pro users can connect MCP apps with read/fetch permissions. Setup and availability vary by plan and product updates—verify current options in OpenAI Help Center.

Traditional ApproachMCP Approach
Copy-paste from Westlaw to ChatGPTChatGPT queries Westlaw directly
Download from iManage, upload to ChatGPTChatGPT accesses iManage directly
Switch between 5 different toolsSingle interface with all tools
Manual data entryAutomated data flow
ServerFunctionStatus
MidpageCase law researchVendor-managed
CourtListenerFree case law databaseOpen source
LegalContextClio document accessVendor-managed
French Legal ResearchFrench law databaseVendor-managed
iManageDocument managementVia API
SharePointDocument storageBuilt-in
Congress APILegislative trackingOpen source
PACERFederal court recordsOpen source
Google ScholarCitation verificationOpen source
RECAPCourt filing alertsOpen source

Part 2: Setting Up Midpage Integration

What Midpage Provides

Midpage is a legal research platform with AI-powered features:

  • Comprehensive US case law database
  • AI-powered citator (good law verification)
  • Semantic search across case law
  • Citation extraction and validation

Integration Benefits

With Midpage + ChatGPT:

  • Research case law without leaving ChatGPT
  • Verify citations are still good law
  • Find relevant precedents for your facts
  • Draft with integrated legal authority

Requirements

  • Midpage subscription
  • ChatGPT plan with MCP support (Business, Enterprise/Edu for full MCP; Pro for read/fetch—verify current plan offerings at OpenAI)
  • Access to apps/connector configuration (Developer Mode; workspace admins enable for Business/Enterprise)

Setup Steps

ChatGPT MCP: Remote Servers Only

ChatGPT connects to remote MCP servers via URL, not local processes. The JSON config patterns below are illustrative; actual setup uses the Apps SDK or Admin settings to register your MCP server endpoint. If you run a local MCP server, expose it via a tunnel or hosting (e.g., Replit, cloud) for ChatGPT to connect.

Step 1: Get Midpage API Credentials

  1. Log into Midpage dashboard
  2. Navigate to Settings -> API Access
  3. Generate API key
  4. Copy key securely

Step 2: Configure MCP in ChatGPT

OpenAI supports MCP in ChatGPT via apps and Developer Mode. Configuration varies by plan and product updates:

  • ChatGPT Plus/Pro: Developer Mode (beta) for MCP apps
  • ChatGPT Team/Enterprise: Workspace admins enable Developer Mode in settings

Add the Midpage MCP server per OpenAI's MCP documentation. Verify the exact package name and setup with Midpage—npm package names and config may change; use the vendor's current integration guide.

Example config pattern (adapt to your deployment—ChatGPT uses remote server URLs, not local command):

{
  "mcpServers": {
    "midpage": {
      "command": "npx",
      "args": ["-y", "@midpage/mcp-server"],
      "env": {
        "MIDPAGE_API_KEY": "your-api-key-here"
      }
    }
  }
}

Step 3: Verify Connection

In ChatGPT, test the connection:

Can you search Midpage for recent California Supreme Court
cases on non-compete agreements?

You should see ChatGPT query Midpage and return case citations.

Implementation Steps:

  1. Obtain Midpage API key from dashboard
  2. Locate ChatGPT MCP/Developer Mode settings (varies by plan)
  3. Add Midpage server config with env var for API key
  4. Restart ChatGPT if required
  5. Run test query; confirm citations are returned

Usage Examples

Example 1: Case Law Research

I'm drafting a motion to compel arbitration in Texas.
Search Midpage for the leading Texas cases on
arbitration enforceability and summarize the current standards.

Example 2: Citation Verification

I want to cite Johnson v. Smith Corp., 234 F.3d 567 (5th Cir. 2020)
in my brief. Use Midpage to verify this citation is still good law.

Example 3: Finding Supporting Authority

My client was terminated after reporting safety violations.
Search Midpage for Texas whistleblower retaliation cases where
the plaintiff prevailed. Focus on cases from the last 5 years.

Privacy & Security

  • Review each provider's trust/security documentation before enabling
  • Minimize data sent to external services
  • Use least-privilege credentials and scoped access
  • Confirm retention and training settings in vendor terms

Part 3: Setting Up CourtListener (Free Alternative)

What CourtListener Provides

CourtListener is a free, open-source legal research database:

  • Federal case law
  • State court opinions
  • Oral arguments
  • PACER integration
  • No subscription required

Setup Steps

Step 1: Install CourtListener MCP

CourtListener offers an API and community MCP integrations. Check CourtListener API and npm for current package names (e.g., @us-legal-tools/courtlistener-sdk or community packages). Example pattern:

npm install -g <courtlistener-mcp-package>

Step 2: Configure in ChatGPT

{
  "mcpServers": {
    "courtlistener": {
      "command": "<mcp-command>",
      "args": ["serve"],
      "env": {
        "COURTLISTENER_API_KEY": "your-api-key"
      }
    }
  }
}

The API key is optional but recommended for higher rate limits. Verify the exact command and package name in the package's documentation.

Step 3: Test Connection

Search CourtListener for Ninth Circuit cases discussing
software license enforceability.

CourtListener vs. Midpage

FeatureCourtListenerMidpage
PriceFreeSubscription
CoverageGood federal, variable stateCommercial legal research coverage
CitatorBasicAI-powered
Update speedVaries by sourceVaries by vendor pipeline
Best forCost-conscious, federal focusFull legal research

Part 4: Document Management Integration

MCP TypeScript Stack (Updated Feb 2026)

For custom MCP servers (e.g., for API integrations or hosting for ChatGPT), use the official SDK:

  • Production-stable: @modelcontextprotocol/sdk (v1.x; see MCP TypeScript SDK)
  • Note: Package structure may evolve; check the official repo for current recommendations.

Install baseline:

npm install @modelcontextprotocol/sdk zod

Option A: LegalContext for Clio

LegalContext enables ChatGPT to access documents stored in Clio securely.

Setup:

{
  "mcpServers": {
    "legalcontext": {
      "command": "npx",
      "args": ["-y", "legalcontext-mcp"],
      "env": {
        "CLIO_API_KEY": "your-clio-api-key"
      }
    }
  }
}

Usage:

Retrieve the Smith v. Jones complaint from our Clio matter files
and summarize the key allegations.

Security: Document processing occurs within your firm's security perimeter.

Option B: SharePoint Integration

SharePoint integration may be available via MCP or built-in connectors. Check OpenAI documentation for current options.

Usage:

Search our SharePoint legal templates folder for NDAs
and list all templates by date modified.

Option C: iManage via API

iManage integration requires custom MCP server setup. The MCP protocol is platform-agnostic; the same server can work with ChatGPT when deployed as a remote endpoint. Use your firm's iManage API client or official SDK; the code below is a conceptual pattern—adapt imports and client usage to your environment.

Step 1: Create iManage API Application

  1. Log into iManage Control Center
  2. Create OAuth2 application
  3. Configure redirect URI
  4. Note Client ID and Secret

Step 2: Build Custom MCP Server

// imanage-mcp.js
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import iManageClient from "imanage-api-client";
 
const server = new McpServer({ name: "imanage", version: "1.0.0" });
 
server.registerTool(
  "search_documents",
  {
    description: "Search iManage for documents",
    inputSchema: z.object({
      query: z.string().describe("Search query"),
      workspace: z.string().describe("Workspace ID"),
    }),
  },
  async ({ query, workspace }) => {
    const client = new iManageClient(process.env.IMANAGE_CREDENTIALS);
    const results = await client.search({ query, workspace });
    return { content: [{ type: "text", text: JSON.stringify(results) }] };
  },
);
 
server.registerTool(
  "get_document",
  {
    description: "Retrieve document content",
    inputSchema: z.object({
      documentId: z.string().describe("Document ID"),
    }),
  },
  async ({ documentId }) => {
    const client = new iManageClient(process.env.IMANAGE_CREDENTIALS);
    const document = await client.getDocument(documentId);
    return { content: [{ type: "text", text: JSON.stringify(document) }] };
  },
);
 
const transport = new StdioServerTransport();
await server.connect(transport);

Step 3: Configure in ChatGPT

{
  "mcpServers": {
    "imanage": {
      "command": "node",
      "args": ["path/to/imanage-mcp.js"],
      "env": {
        "IMANAGE_CREDENTIALS": "path/to/credentials.json"
      }
    }
  }
}

Combine multiple MCP sources for thorough research:

I need to research the enforceability of liquidated damages
clauses in software agreements under Delaware law.

Workflow:
1. Search Midpage for Delaware cases on liquidated damages
2. Search CourtListener for federal cases applying Delaware law
3. Pull our firm's memo on liquidated damages from SharePoint
4. Synthesize into a research summary

ChatGPT Response Pattern:

Let me research this across multiple sources...

## Midpage Results (Delaware State Cases)
[ChatGPT queries Midpage, returns cases]

## CourtListener Results (Federal/Delaware Law)
[ChatGPT queries CourtListener, returns additional cases]

## Firm Precedent (SharePoint)
[ChatGPT retrieves firm memo]

## Synthesis
Based on my research across these sources:

The leading Delaware case is [X], which established...
Federal courts applying Delaware law have held...
Our firm's prior analysis in the [Client] matter noted...

**Key Takeaways**:
1. Delaware generally enforces liquidated damages if...
2. The "reasonableness" test requires...
3. Our recommended approach is...

**Citations** (verified via Midpage citator):
- [Citation 1] - Still good law
- [Citation 2] - Still good law

Workflow Synthesis Best Practices

PracticePurpose
Cite sources explicitlyTrace each conclusion to Midpage/CourtListener/firm doc
Flag conflictsIf sources disagree, note and explain
Prioritize by strengthLead with controlling authority; secondary sources follow
Include verification statusState which citations were checked and remain good law

Workflow 2: Contract + Research Integration

[Upload software agreement]

[ChatGPT identifies concerning liability provision under CA law]

"I've flagged the liability limitation as potentially problematic.
Let me research California's position on liability caps in
software agreements..."

[ChatGPT queries Midpage for CA cases]

"Based on my research, California courts have held that [X].
The clause as drafted may be enforceable because [Y], but
you should consider [Z] modification."

Workflow 3: Due Diligence Research

We're acquiring a company in the healthcare space.
Research the regulatory landscape:

1. Search our SharePoint for prior healthcare M&A memos
2. Search Midpage for recent HIPAA enforcement actions
3. Search for FTC healthcare antitrust cases
4. Generate a due diligence issue checklist

Part 6: Advanced MCP Configuration

Running Multiple MCP Servers

{
  "mcpServers": {
    "midpage": {
      "command": "npx",
      "args": ["-y", "@midpage/mcp-server"],
      "env": { "MIDPAGE_API_KEY": "key1" }
    },
    "courtlistener": {
      "command": "courtlistener-mcp",
      "args": ["serve"]
    },
    "legalcontext": {
      "command": "npx",
      "args": ["-y", "legalcontext-mcp"],
      "env": { "CLIO_API_KEY": "key2" }
    },
    "sharepoint": {
      "command": "npx",
      "args": ["-y", "@microsoft/sharepoint-mcp"]
    }
  }
}

Environment-Specific Configuration

Create different configs for different use cases:

# Legal research config
export OPENAI_MCP_CONFIG=~/.openai/mcp-research.json
 
# Contract review config
export OPENAI_MCP_CONFIG=~/.openai/mcp-contracts.json
 
# Full access config
export OPENAI_MCP_CONFIG=~/.openai/mcp-full.json

Configuration paths and environment variables vary by deployment. When using ChatGPT with remote MCP servers, workspace admins typically configure server endpoints via the Apps SDK or Admin settings rather than local env vars. For self-hosted or tunneled MCP servers, use environment-specific configs to switch between research-only, contract-only, and full-integration setups.

Debugging MCP Connections

Check MCP status:

What MCP servers do you have access to right now?
List each server and its available tools.

Test specific tool:

Test the Midpage search tool by searching for "contract breach"
and report any errors.

Troubleshooting MCP Connections

IssuePossible CauseAction
MCP server not listedConfig not loadedRestart ChatGPT; verify config path
"No tools available"Server failed to startCheck env vars; run server manually to test
Timeout on tool callNetwork or API rate limitRetry; check provider status
Wrong results from searchQuery too broad/narrowRefine query; add jurisdiction/date filters
Citation verification failsMidpage API or key issueVerify API key; check Midpage subscription

MCP Connection Health Check

Before relying on MCP for production work:

CheckHow to Verify
Server reachableAsk ChatGPT: "What MCP servers do you have access to?"
Tools listedRequest: "List each server and its available tools"
Search worksRun test query: "Search Midpage for [topic] in [jurisdiction]"
Citation check worksVerify one known citation via Midpage
Remote URL validIf self-hosted, confirm tunnel/URL is active

Part 7: Security Considerations

Data Flow

Your Query
    |
ChatGPT (OpenAI Servers)
    |
MCP Server (Your Control)
    |
External Service (Midpage/iManage/etc.)

Security Best Practices

Credential Management:

  • Never commit API keys to version control
  • Use environment variables
  • Rotate keys regularly
  • Use separate keys for different purposes

Access Control:

  • Limit MCP server access to necessary data
  • Use read-only access where possible
  • Audit MCP server logs
  • Disable unused integrations

Client Data:

  • Understand each service's data handling
  • Check for SOC 2, ISO 27001 certification
  • Review service DPAs
  • Consider which matters can use which integrations

compliance check

  • All MCP services reviewed for security
  • API keys stored securely
  • Access logs enabled
  • data processing agreements in place
  • Client consent obtained where required
  • Firm IT approved configuration

Data Handling by Provider

ProviderData LocationRetentionTraining
MidpageVendor-hostedReview vendor termsReview vendor terms
CourtListenerFree Law ProjectPublic recordsN/A
LegalContextFirm perimeterPer vendor DPAPer vendor DPA
iManageYour infrastructureYour policyYour control
SharePointYour tenantYour policyYour control

Review each provider's trust center and data processing agreements before enabling client data access.


Part 8: Statutory Research Workflow

Legislative Tracking Integration

Connect to Congress API for real-time legislative monitoring:

Setup:

{
  "mcpServers": {
    "congress": {
      "command": "npx",
      "args": ["-y", "@open-legal-tools/congress-mcp"],
      "env": {
        "CONGRESS_API_KEY": "optional-api-key"
      }
    }
  }
}

Statute Version Comparison

Workflow for comparing statute versions across legislative sessions:

Research task:
Track amendments to the California CCPA across its
legislative history and identify key changes by session.

ChatGPT multi-step workflow:
1. Query Congress API for CCPA bill history
2. Retrieve full text for versions from 2018, 2020, 2023
3. Compare key sections (scope, penalties, exemptions)
4. Generate side-by-side amendment analysis
5. Flag enforcement implications of changes

Pattern for comprehensive regulatory research:

Query: "Search all HIPAA regulations (45 CFR 160-164)
related to breach notification requirements and identify
which sections were modified in the last 3 years."

ChatGPT workflow:
1. Query regulatory database for HIPAA sections
2. Cross-reference Federal Register for amendments
3. Pull relevant case law on HIPAA enforcement (via Midpage)
4. Compile regulatory timeline
5. Provide implementation checklist for compliance

Bill Tracking Workflows

Set up tracking for legislation affecting your practice:

Monitor bills matching: [keywords], jurisdictions: [states/federal],
stages: [introduced, hearing, floor, etc.]

ChatGPT can use Congress API MCP to:
- Search for bills by topic
- Compare bill versions across sessions
- Track amendments
- Retrieve sponsor info

Statutory Research Checklist

StepActionMCP Tool
1Identify controlling statute and jurisdictionCongress API; regulation tracker
2Retrieve current version and legislative historyCongress API
3Compare versions across sessionsCongress API; custom compare tool
4Cross-reference case law on interpretationMidpage; CourtListener
5Compile compliance timelineFederal Register; regulation tracker

Part 9: Citation Verification Process

Automated Cite-Checking

Implement citation verification directly in legal writing:

Upload legal brief to ChatGPT with instruction:
"Verify every case citation in this brief is still good law
and identify any corrections needed."

ChatGPT workflow:
1. Extract all citations (Midpage tool)
2. Check each citation status (Midpage citator)
3. Identify overruled/reversed cases
4. Generate citation correction report
5. Flag negative law that contradicts arguments

Shepardizing/KeyCiting Equivalents

Process for verifying citation authority strength:

Citation verification prompt:
"For the following cases, provide Shepard's analysis:
- Smith v. Jones, 234 F.3d 567 (5th Cir. 2020)
- Brown v. Green Corp., 890 P.2d 123 (Cal. 2019)

For each case:
1. Current status (good law/overruled/limited)
2. Citing cases (positive/negative treatment)
3. Strength of authority for this proposition
4. Alternative authorities if weakened"

Good Law Verification System

Configuration for automated citation checking:

{
  "mcpServers": {
    "midpage": {
      "command": "npx",
      "args": ["-y", "@midpage/mcp-server"],
      "tools": [
        "search_cases",
        "verify_citation_status",
        "find_citing_cases",
        "check_negative_law"
      ],
      "env": {
        "MIDPAGE_API_KEY": "your-api-key"
      }
    },
    "google-scholar": {
      "command": "npx",
      "args": ["-y", "google-scholar-mcp"],
      "tools": ["search_scholar", "verify_citations"]
    }
  }
}

Tool availability depends on the MCP server implementation. Midpage typically exposes search, citation verification, and citing-case lookup; ChatGPT discovers available tools automatically when the server is connected.

Citation Verification Workflow Options

WorkflowUse CasePrimary Tool
Good law checkVerify citation still validMidpage citator
Shepard's-style analysisPositive/negative treatmentMidpage + citing cases
Format validationBluebook/ALWD compliancePrompt-based or custom MCP
Batch brief reviewFull document cite-checkMidpage + document upload

Best practices for cite-checking with ChatGPT:

  • Run verification before finalizing any brief or memo
  • Request both status (good law) and format (Bluebook/ALWD) in one pass when possible
  • For critical citations, ask for alternative authorities if status is weakened
  • Document which MCP tools were used for each verification in your work product

Citation Output Quality

Output ElementWhat to Request
StatusGood law / Overruled / Limited / Distinguished
TreatmentPositive, negative, or neutral citing cases
AlternativesStronger authorities if current citation weakened
FormatBluebook/ALWD normalized and corrected citation

Citation Format Validation

Workflow for standardizing citations:

Upload brief with instruction:
"Validate every citation in this document for Bluebook/ALWD format.
For each citation: provide original, normalized form, formatted output,
and any corrections needed. Generate a citation correction report."

Part 10: Court Records Alert Setup

Real-Time Case Filing Alerts

Configure PACER integration for docket monitoring:

Setup PACER MCP Server:

{
  "mcpServers": {
    "pacer": {
      "command": "npx",
      "args": ["-y", "@open-legal-tools/pacer-mcp"],
      "env": {
        "PACER_USERNAME": "your-pacer-login",
        "PACER_PASSWORD": "your-pacer-password",
        "PACER_CLIENT_CODE": "your-client-code"
      }
    },
    "recap": {
      "command": "npx",
      "args": ["-y", "@free-law-project/recap-mcp"]
    }
  }
}

Docket Monitoring

Automated docket tracking workflow:

Monitor docket: Smith v. Jones, Case No. 2023-CV-12345

Daily workflow:
1. Check for new filings (PACER alert)
2. Extract filing metadata (date, filer, document type)
3. Download documents if Rule 34 request received
4. Flag critical events (depositions, trial dates)
5. Summarize for team

Large-Scale Court Records Search Patterns

Query patterns for comprehensive court records search (RECAP and PACER provide access to millions of federal court documents):

Workflow: Competitive intelligence monitoring

Setup alert for:
- All cases involving Company X in federal courts
- Parties: Company X (plaintiff or defendant)
- Date range: Last 2 years

ChatGPT multi-source search:
1. Query PACER for Company X docket entries
2. Search RECAP for public documents
3. Cross-reference state court records (where available)
4. Extract defendants/plaintiffs for analysis
5. Generate competitive threat assessment

Party-Based Tracking

Monitor all matters involving specific parties:

Query: "Track all cases involving [party name] as [plaintiff/defendant]
in [courts]. Provide: total cases, active cases, docket summaries,
and competitive analysis of party litigation history."

Part 11: Agentic Multi-Step Research Pattern

Execute complex research tasks with agent-like behavior:

Research request:
"My client is negotiating a software licensing agreement
with a major tech company. Research the landscape of:
1. Recent software licensing disputes
2. Key contract provisions courts scrutinize
3. Best practices from firm precedents
4. Relevant patent litigation affecting licensing
5. Synthesize into deal negotiation memo"

ChatGPT agent workflow:
Step 1: Research Phase
  - Query Midpage for software licensing cases (last 5 years)
  - Extract critical issues from leading cases

Step 2: Precedent Phase
  - Search SharePoint for firm's prior licensing agreements
  - Extract successful clause language
  - Identify deal-breaker provisions by client type

Step 3: Patent Phase
  - Search Google Patents for relevant technology patents
  - Identify software licensing implications
  - Flag cross-license requirements

Step 4: Synthesis Phase
  - Organize findings by provision (IP ownership, liability, etc.)
  - Cross-reference case law to deal terms
  - Generate risk assessment matrix

Step 5: Deliverable Phase
  - Create negotiation memo with:
    * Market landscape summary
    * Key case takeaways
    * Recommended provisions
    * Risk mitigation strategies

Research Plan Generation

Workflow for automatic research planning:

User: "I need to understand California's position on
non-compete agreements in employment contracts.
What should I research?"

ChatGPT research planner:
"I'll develop a research plan covering:

Phase 1: Controlling Authority
  - California Supreme Court cases on non-competes
  - Test: Is non-compete reasonable? (Blue Pencil doctrine)
  - Key cases: Silguero, Edwards, Morbi

Phase 2: Legislature Response
  - California Business & Professions Code 16600
  - Legislative amendments (2024 updates)
  - Statutory interpretation

Phase 3: Modern Applications
  - Recent Court of Appeal decisions (2023-2025)
  - Non-compete vs. non-solicitation distinction
  - Remote work implications

Phase 4: Practical Synthesis
  - Enforceable provisions despite 16600
  - Trade secret protection alternatives
  - Employment agreement drafting best practices

Estimated research time: 2-3 hours
Key sources: Midpage, firm memos, Bar Association guidance"

Iterative Refinement

Build research workflows that improve with each iteration:

Initial query: "California non-compete enforceability"

Iteration 1: Initial results show non-competes generally unenforceable
  -> Questions: Legitimate business interests exception? C-suite application?

Iteration 2: Refined searches for exceptions, executive contracts, remote work
  -> New findings: Narrow exceptions for limited legitimate interests

Iteration 3: Targeted research on 16600 interpretation, blue pencil doctrine
  -> Synthesis: Actionable guidance for client

Part 12: Case Law Analytics Interpretation

Judge Behavior Analytics

Integrate judicial analytics for litigation strategy:

Query: "Judge Smith handles patent licensing disputes
in the Northern District of California. What patterns
can I identify in her decisions?"

Analytics workflow:
1. Search RECAP for all Judge Smith cases
2. Extract relevant patent licensing decisions
3. Analyze patterns:
   - Grant rate on summary judgment motions
   - Treatment of injunction requests
   - Damages awards (high/low/reasonable)
   - Attitude toward expert witnesses
4. Compare to district averages
5. Generate litigation strategy recommendations

Attorney Performance Data

Track opposing counsel patterns:

Workflow: Opposing Counsel Analysis

For: Attorney Jane Doe (plaintiff's counsel)

Metrics extracted (illustrative example):
- Settlement rate vs. district average
- Trial win rate
- Typical verdict range for case type
- Expert witness preferences
- Motion practice: Aggressive discovery requests
- Deposition style: Confrontational

Strategic implications:
- Prepare for aggressive discovery
- Expect push to trial
- May be open to structured settlements
- Anticipated expert witnesses based on historical patterns

Outcome Prediction Patterns

Data-driven outcome assessment:

Query: "Predict the likely outcome of our employment
discrimination case with Judge Smith in NDCA."

Analysis:
1. Historical data: Judge Smith's discrimination cases
2. Factors: Strength of evidence, damages, settlement history
3. Prediction: Probability of plaintiff success in trial
4. Outcome distribution: Summary judgment, trial, settlement
5. Median award range if plaintiff prevails
6. Confidence interval

Settlement Range Analysis

Data-driven settlement valuation:

Query: "Analyze historical settlements for [case type] in [jurisdiction]
before Judge [name]. Claimed damages: $X. Provide:
- Predicted low/mid/high settlement range
- Confidence level
- Comparable cases
- Key factors affecting range

Part 13: Comparison to Enterprise Solutions

ChatGPT + MCP vs. Harvey Integration

AspectChatGPT + MCPHarvey
SetupDIY or simple configVendor-managed
CustomizationFull controlLimited
Research sourcesChoose your ownHarvey's selected sources
Document managementConnect any systemHarvey Vault only
Pricing modelPer-tool/service mixAll-in-one enterprise contracts
MaintenanceYou manageHarvey manages

When to Choose Each

Choose ChatGPT + MCP when:

  • You want control over integrations
  • Cost is a significant factor
  • You have IT resources for setup
  • You use non-standard tools

Choose Harvey/Legora when:

  • You want turnkey solution
  • Enterprise support is required
  • Budget allows premium pricing
  • You need vendor accountability

Do This Now

  • Set up Midpage or CourtListener in ChatGPT MCP settings
  • Run a case law search and confirm ChatGPT returns citations
  • Verify one citation is still good law using the citator
  • Try a multi-source research task (e.g., case law + firm documents)
  • Document your setup for your team

Quick Reference: MCP Server Commands

Midpage

Search for [topic] cases in [jurisdiction]
Verify citation [citation] is still good law
Find cases that cite [case name]
Check if [case] has been overruled or limited

CourtListener

Search CourtListener for [query]
Get full text of [case citation]
Find oral arguments in [case]
Search by judge: [judge name] in [court]

Legislative & Regulatory

Search Congress for bills matching [criteria]
Track amendments to [statute] by year
Compare versions of [bill] across sessions
Search Federal Register for [regulation changes]
Monitor bills in [state legislature] related to [topic]

Court Records

Search PACER for cases involving [party name]
Get docket for [case number] in [court]
Set alert for filings in [case number]
Search RECAP for [party] across all federal courts
Find all cases by Judge [judge name]

Citation Verification

Verify citation [citation] is still good law
Check Shepard's for [case]: positive/negative treatment
Find alternative authorities for [proposition]
Validate citation format for [citation] (Bluebook/ALWD)

Document Management

Search [system] for documents matching [criteria]
Retrieve document [name/ID] from [location]
List recent documents in [workspace/folder]

Analytics & Insights

Analyze Judge [judge name] decision patterns for [case type]
Predict settlement range for [case type] before Judge [judge]
Compare outcome patterns for opposing counsel [attorney name]
Calculate motion grant rates for [judge] on [motion type]

Previous: Legal Plugin | Next: Cowork Automation



Sources

Additional Reading