Build a rag legal research assistant that drafts briefs in under 10 minutes

You can spin up a Retrieval-Augmented Generation (RAG) legal research assistant in a few hours, hook it up to public case-law APIs, and have it return a concise brief in roughly ten minutes of work. The system combines a vector store of recent opinions, LangChain orchestration, and OpenAI's text-creation model so you retrieve the most relevant cases, summarize them, and let the LLM draft a brief - all with a single click.

*Pricing is accurate as of August 2026; verify on the provider's pricing page before you start.

Estimated build time: 4-6 hours for a developer comfortable with Python and basic HTTP auth.

The following recipe creates a command-line tool brief.py that accepts a legal question, retrieves the top-5 relevant opinions from CourtListener, summarizes each, and asks OpenAI to write a 300-word brief. Every step is reproducible; you can later wrap it in a Flask app or n8n workflow for internal law-firm software.

Create an isolated virtual environment and install the required libraries.

python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install langchain openai pinecone-client tqdm requests

If you prefer a fully local vector store, replace pinecone-client with chromadb.

Tip: Keep the environment file (requirements.txt) in version control so you can rebuild the stack on a new machine with pip install -r requirements.txt.

legal-cases). Record the us-west1-gcp). User-Agent header as recommended in the API docs. Store the secrets in a .env file (never commit it).

OPENAI_API_KEY=sk-XXXXXXXXXXXXXXXXXXXXXXXX
PINECONE_API_KEY=YOUR_PINECONE_KEY
PINECONE_ENV=us-west1-gcp

Load them in code with python-dotenv (install pip install python-dotenv) or use os.getenv.

The script below fetches the latest 200 opinions from CourtListener (via the /search/ endpoint), extracts the plain_text, embeds each with OpenAI's text-embedding-ada-002, and upserts into Pinecone. The process runs once and can be scheduled weekly.

import os, time, json, requests
from dotenv import load_dotenv
from langchain.embeddings import OpenAIEmbeddings
import pinecone

load_dotenv()
pinecone.init(api_key=os.getenv("PINECONE_API_KEY"),
 environment=os.getenv("PINECONE_ENV"))

index_name = "legal-cases"
if index_name not in pinecone.list_indexes():
 pinecone.create_index(name=index_name, dimension=1536, metric="cosine")
index = pinecone.Index(index_name)

embeddings = OpenAIEmbeddings(openai_api_key=os.getenv("OPENAI_API_KEY"))

def fetch_cases(page=1, page_size=20):
 url = "https://www.courtlistener.com/api/rest/v3/search/"
 params = {
 "type": "opinion",
 "page": page,
 "page_size": page_size,
 "order_by": "-date_filed"
 }
 headers = {"User-Agent": "YourLawFirmRAG/1.0"}
 resp = requests.get(url, params=params, headers=headers)
 resp.raise_for_status()
 return resp.json()["results"]

vectors = []
for page in range(1, 11): # 10 pages × 20 = 200 cases
 cases = fetch_cases(page=page, page_size=20)
 for case in cases:
 text = case.get("plain_text", "")
 if not text:
 continue
 embed = embeddings.embed_query(text) # 1536-dim vector
 vectors.append((case["id"], embed, {"title": case["case_name"], "date": case["date_filed"]}))
 time.sleep(1) # respect 1 req/s limit

batch_size = 100
for i in range(0, len(vectors), batch_size):
 batch = vectors[i:i+batch_size]
 index.upsert(vectors=batch)
print(f"Upserted {len(vectors)} case embeddings.")

What this does: pulls 200 recent opinions, turns each into a 1536-dim embedding, and stores them in a Pinecone index named legal-cases. After the initial run you have a searchable knowledge base that can be refreshed on a cron schedule.

Now write the core assistant in brief.py. It takes a user query, retrieves the top-5 most similar cases, asks OpenAI to summarize each, and finally composes a brief.

import os, sys, json
from dotenv import load_dotenv
from langchain.vectorstores import Pinecone
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from tqdm import tqdm

load_dotenv()
embeddings = OpenAIEmbeddings(openai_api_key=os.getenv("OPENAI_API_KEY"))
vectorstore = Pinecone.from_existing_index(
 index_name="legal-cases",
 embedding=embeddings,
 namespace=None
)

SUMMARIZE_PROMPT = PromptTemplate(
 input_variables=["case_text", "question"],
 template=(
 "You are a seasoned legal analyst. Summarize the following case excerpt "
 "in 120 words, focusing on how it answers the question: '{question}'.\n\n"
 "{case_text}"
 )
)

BRIEF_PROMPT = PromptTemplate(
 input_variables=["question", "summaries"],
 template=(
 "Write a short (≈300-word) legal brief that answers the question:\n"
 "\"{question}\"\n"
 "Use only the information from the following case summaries. "
 "Cite each summary with its title and date in parentheses.\n\n"
 "{summaries}"
 )
)

def retrieve_and_summarize(question: str, top_k: int = 5):
 docs = vectorstore.similarity_search(question, k=top_k)
 llm = OpenAI(model="gpt-3.5-turbo", temperature=0.2, openai_api_key=os.getenv("OPENAI_API_KEY"))
 summarize_chain = LLMChain(llm=llm, prompt=SUMMARIZE_PROMPT)

 summaries = []
 for doc in tqdm(docs, desc="Summarizing cases"):
 summary = summarize_chain.run({"case_text": doc.page_content, "question": question})
 meta = doc.metadata
 header = f"**{meta.get('title', 'Unknown')} ({meta.get('date', 'N/A')})**"
 summaries.append(f"{header}\n{summary}\n")
 return "\n".join(summaries)

def draft_brief(question: str, summaries: str):
 llm = OpenAI(model="gpt-3.5-turbo", temperature=0.3, openai_api_key=os.getenv("OPENAI_API_KEY"))
 brief_chain = LLMChain(llm=llm, prompt=BRIEF_PROMPT)
 return brief_chain.run({"question": question, "summaries": summaries})

if __name__ == "__main__":
 if len(sys.argv) < 2:
 print("Usage: python brief.py \"Legal question here\"")
 sys.exit(1)
 user_question = sys.argv[1]
 print("🔎 Retrieving relevant opinions...")
 case_summaries = retrieve_and_summarize(user_question)
 print("\n✍️ Drafting brief...")
 result = draft_brief(user_question, case_summaries)
 print("\n=== GENERATED BRIEF ===\n")
 print(result)

What this does:

gpt-3.5-turbo with a focused prompt, producing a concise 120-word synopsis. Running python brief.py "When does the doctrine of laches apply in patent infringement?" typically finishes in under 10 seconds of compute time, leaving you with a ready-to-send draft.

Law-firm software often prefers HTTP endpoints. The snippet below wraps the above logic in a /brief endpoint that accepts JSON { "question": "..." } and returns the brief.

from flask import Flask, request, jsonify
from brief import retrieve_and_summarize, draft_brief

app = Flask(__name__)

@app.route("/brief", methods=["POST"])
def generate_brief():
 payload = request.get_json()
 if not payload or "question" not in payload:
 return jsonify({"error": "Missing 'question' field"}), 400
 question = payload["question"]
 summaries = retrieve_and_summarize(question)
 brief = draft_brief(question, summaries)
 return jsonify({"brief": brief})

if __name__ == "__main__":
 app.run(host="0.0.0.0", port=8000)

Deploy this container with Docker for sandboxed execution inside your firm's DMZ:

docker build -t rag-legal-assistant .
docker run -d -p 8000:8000 --env-file .env rag-legal-assistant

Now any internal tool can POST a legal question and receive a polished brief in under a minute.

Warning: The OpenAI API does not guarantee that generated citations are accurate. Always run a secondary check (e.g., a quick search on the original case IDs) before filing any document.

For a deeper technical reference, see OpenAI's docs.

A single brief typically uses ~1 500 tokens for retrieval-summaries and ~3 000 tokens for the final draft. At $0.002 / 1 k tokens, the API cost is roughly $0.009 per request, plus negligible Pinecone read-costs in the free tier.

Yes. Chroma, Weaviate, or FAISS are all compatible with LangChain. Swap the Pinecone import for langchain.vectorstores.Chroma and change the vectorstore initialization accordingly; no other code changes are required.

CourtListener data is released under the Creative Commons Zero (CC0) license, allowing unrestricted commercial use. However, you should still attribute the source per the API's terms of service: include "Data sourced from CourtListener (https://www.courtlistener.com)".

Filter the ingestion step by tags (taxonomy query parameters) to collect only tax-related opinions, or create a separate Pinecone index named tax-cases. Adjust the top_k parameter in brief.py to retrieve more specialized materials.

Run the entire stack inside Docker without external network access after the initial ingestion. Use the text-embedding-ada-002 model via the OpenAI Azure private endpoint, or replace it with a locally hosted embedding model such as sentence-transformers/all-mpnet-base-v2.

Building a rag legal research assistant that pulls case law from public APIs and drafts briefs in about ten minutes is entirely feasible with openly available tools. By structuring the workflow with LangChain, a vector store, and OpenAI's generation models, you get a reproducible pipeline that law firms can internalize, brand, and sell as a productivity-boosting service.

If you're hungry for more ready-made automations you can offer to clients, check out our guide to AI automations you can sell. And for a deeper dive into prompt engineering and RAG best practices, grab the free guide.

Happy building, and remember: the real value comes from the curation of the right cases, not from a flashier model.