cjeu-mcp 1.0.0

package/README.md

@@ -0,0 +1,61 @@
+# cjeu-mcp
+
+MCP server that gives Claude access to EU Court of Justice case law. Search cases by number or keyword, read full judgments, AG opinions, and orders directly in Claude.
+
+## Install
+
+```bash
+npm install -g cjeu-mcp
+```
+
+## Configure for Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "cjeu": {
+      "command": "npx",
+      "args": ["-y", "cjeu-mcp"]
+    }
+  }
+}
+```
+
+## Available Tools
+
+### `search_case`
+
+Search for all documents related to a CJEU case number.
+
+**Example prompts:**
+- "Find all documents for case C-131/12"
+- "What documents are available for C-362/14?"
+- "Download links for all documents in T-750/21"
+
+### `get_document`
+
+Get a CJEU document by CELEX number — either as readable text (for analysis) or as PDF download URLs.
+
+**Example prompts:**
+- "Read the judgment in case C-131/12" (use `search_case` first to find the CELEX number, then `get_document`)
+- "Read the AG opinion in case C-362/14 and summarize the key arguments"
+- "Compare the judgment and AG opinion in C-311/18 — did the Court follow the AG?"
+
+### `search_by_keyword`
+
+Search CJEU case law by keyword, with optional year and court filters.
+
+**Example prompts:**
+- "Search for CJEU cases about data protection from 2020"
+- "Find General Court cases about state aid"
+- "Search for recent cases about Article 101 TFEU"
+
+## Data Source
+
+All data comes from the [EU Cellar](https://publications.europa.eu/) SPARQL endpoint and REST API — the official open data repository of the EU Publications Office. No authentication required.
+
+## License
+
+MIT

package/dist/celex.d.ts

@@ -0,0 +1,9 @@
+/** Case number normalization and CELEX conversion — ported from app.py */
+export interface ParsedCase {
+    prefix: string;
+    numberPadded: string;
+    fullYear: number;
+    formatted: string;
+}
+export declare function parseCaseNumber(raw: string): ParsedCase | null;
+export declare function typeUriToLabel(uri: string): string;

package/dist/celex.js

@@ -0,0 +1,38 @@
+/** Case number normalization and CELEX conversion — ported from app.py */
+const TYPE_LABELS = {
+    JUDG: "Judgment",
+    ORDER: "Order",
+    OPIN_AG: "Opinion of Advocate General",
+    VIEW_AG: "View of Advocate General",
+};
+export function parseCaseNumber(raw) {
+    let s = raw.trim();
+    // Normalize dashes (en-dash, em-dash, non-breaking hyphen)
+    s = s.replace(/\u2011/g, "-").replace(/\u2013/g, "-").replace(/\u2014/g, "-");
+    // Remove leading "Case"
+    s = s.replace(/^case\s+/i, "");
+    const m = s.match(/^([CT])[\s-]*(\d+)\s*\/\s*(\d+)$/i);
+    if (!m)
+        return null;
+    const prefix = m[1].toUpperCase();
+    const number = parseInt(m[2], 10);
+    const yearShort = m[3];
+    let fullYear;
+    if (yearShort.length === 4) {
+        fullYear = parseInt(yearShort, 10);
+    }
+    else {
+        const y = parseInt(yearShort, 10);
+        fullYear = y >= 54 ? 1900 + y : 2000 + y;
+    }
+    const numberPadded = String(number).padStart(4, "0");
+    const formatted = `${prefix}-${number}/${yearShort}`;
+    return { prefix, numberPadded, fullYear, formatted };
+}
+export function typeUriToLabel(uri) {
+    for (const [key, label] of Object.entries(TYPE_LABELS)) {
+        if (uri.endsWith("/" + key))
+            return label;
+    }
+    return uri.split("/").pop() ?? uri;
+}

package/dist/cellar.d.ts

@@ -0,0 +1,21 @@
+/** Cellar REST API download + content negotiation — ported from app.py */
+/**
+ * Fetch the HTML version of a document and extract clean legal text.
+ * Strategy (matches app.py):
+ *  1. Try Cellar HTML manifestation URL (if known)
+ *  2. Try Cellar content negotiation: GET celex URI with Accept: xhtml
+ *  3. Try EUR-Lex HTML
+ */
+export declare function fetchDocumentText(celex: string, htmlManifUrl?: string): Promise<string | null>;
+/**
+ * Get PDF download URLs for a document.
+ */
+export declare function getPdfUrls(celex: string, pdfManifUrl?: string): string[];
+/**
+ * Look up manifestation URLs for a CELEX by querying SPARQL.
+ * Returns { pdfUrl, htmlUrl } if found.
+ */
+export declare function lookupManifestations(celex: string): Promise<{
+    pdfUrl: string;
+    htmlUrl: string;
+}>;

package/dist/cellar.js

@@ -0,0 +1,137 @@
+/** Cellar REST API download + content negotiation — ported from app.py */
+import * as cheerio from "cheerio";
+const FETCH_TIMEOUT = 30_000;
+function log(msg) {
+    process.stderr.write(`[cjeu-mcp] ${msg}\n`);
+}
+async function fetchWithTimeout(url, init = {}) {
+    return fetch(url, {
+        ...init,
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+        redirect: "follow",
+    });
+}
+/**
+ * Fetch the HTML version of a document and extract clean legal text.
+ * Strategy (matches app.py):
+ *  1. Try Cellar HTML manifestation URL (if known)
+ *  2. Try Cellar content negotiation: GET celex URI with Accept: xhtml
+ *  3. Try EUR-Lex HTML
+ */
+export async function fetchDocumentText(celex, htmlManifUrl) {
+    const urls = [];
+    if (htmlManifUrl)
+        urls.push(htmlManifUrl);
+    // Cellar content negotiation is unreliable for celex URIs (often 404),
+    // but the manifestation URL works, so we skip celex negotiation for HTML.
+    urls.push(`https://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri=CELEX:${celex}`);
+    for (const url of urls) {
+        try {
+            const resp = await fetchWithTimeout(url, {
+                headers: {
+                    Accept: "application/xhtml+xml, text/html",
+                    "Accept-Language": "eng",
+                    "User-Agent": "cjeu-mcp/1.0",
+                },
+            });
+            if (!resp.ok)
+                continue;
+            const ct = resp.headers.get("content-type") ?? "";
+            if (!ct.includes("html") && !ct.includes("xhtml"))
+                continue;
+            const html = await resp.text();
+            if (!html.trim())
+                continue;
+            // EUR-Lex WAF returns 202 with JS challenge
+            if (resp.status === 202 || html.includes("awsWafCookie"))
+                continue;
+            return extractLegalText(html);
+        }
+        catch (e) {
+            log(`fetchDocumentText failed for ${url}: ${e}`);
+        }
+    }
+    return null;
+}
+/**
+ * Get PDF download URLs for a document.
+ */
+export function getPdfUrls(celex, pdfManifUrl) {
+    const urls = [];
+    if (pdfManifUrl)
+        urls.push(pdfManifUrl);
+    urls.push(`https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:${celex}`);
+    return urls;
+}
+/**
+ * Look up manifestation URLs for a CELEX by querying SPARQL.
+ * Returns { pdfUrl, htmlUrl } if found.
+ */
+export async function lookupManifestations(celex) {
+    const query = `
+PREFIX cdm: <http://publications.europa.eu/ontology/cdm#>
+SELECT ?pdfManif ?htmlManif WHERE {
+  ?work cdm:resource_legal_id_celex ?celex .
+  FILTER(STR(?celex) = "${celex}")
+  ?expression cdm:expression_belongs_to_work ?work .
+  ?expression cdm:expression_uses_language <http://publications.europa.eu/resource/authority/language/ENG> .
+  OPTIONAL {
+    ?pdfManif cdm:manifestation_manifests_expression ?expression .
+    ?pdfManif cdm:manifestation_type ?pmtype .
+    FILTER(CONTAINS(STR(?pmtype), "pdf"))
+  }
+  OPTIONAL {
+    ?htmlManif cdm:manifestation_manifests_expression ?expression .
+    ?htmlManif cdm:manifestation_type ?hmtype .
+    FILTER(STR(?hmtype) = "xhtml" || STR(?hmtype) = "html")
+  }
+}
+LIMIT 1`;
+    const url = new URL("https://publications.europa.eu/webapi/rdf/sparql");
+    url.searchParams.set("query", query);
+    try {
+        const resp = await fetchWithTimeout(url.toString(), {
+            headers: {
+                Accept: "application/sparql-results+json",
+                "User-Agent": "cjeu-mcp/1.0",
+            },
+        });
+        if (!resp.ok)
+            return { pdfUrl: "", htmlUrl: "" };
+        const data = await resp.json();
+        const row = data.results.bindings[0];
+        if (!row)
+            return { pdfUrl: "", htmlUrl: "" };
+        const pdf = row.pdfManif?.value ?? "";
+        const html = row.htmlManif?.value ?? "";
+        return {
+            pdfUrl: pdf ? pdf + "/DOC_1" : "",
+            htmlUrl: html ? html + "/DOC_1" : "",
+        };
+    }
+    catch {
+        return { pdfUrl: "", htmlUrl: "" };
+    }
+}
+/**
+ * Extract clean legal text from an HTML document using cheerio.
+ * Strips navigation, headers, footers, metadata — keeps only the legal content.
+ */
+function extractLegalText(html) {
+    const $ = cheerio.load(html);
+    // Remove non-content elements
+    $("head, script, style, link, meta, nav, header, footer").remove();
+    $('[class*="banner"], [class*="cookie"], [id*="nav"], [id*="header"], [id*="footer"]').remove();
+    $('[class*="breadcrumb"], [class*="sidebar"], [class*="menu"]').remove();
+    // Get text from body
+    let text = $("body").text();
+    // Clean up whitespace: collapse multiple newlines/spaces
+    text = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .join("\n");
+    // Collapse runs of 3+ newlines to 2
+    text = text.replace(/\n{3,}/g, "\n\n");
+    return text.trim();
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { parseCaseNumber } from "./celex.js";
+import { queryCellar, queryFirstInstance, searchByKeyword, } from "./sparql.js";
+import { fetchDocumentText, getPdfUrls, lookupManifestations, } from "./cellar.js";
+function log(msg) {
+    process.stderr.write(`[cjeu-mcp] ${msg}\n`);
+}
+const server = new McpServer({
+    name: "cjeu-mcp",
+    version: "1.0.0",
+});
+// ---------------------------------------------------------------------------
+// Tool 1: search_case
+// ---------------------------------------------------------------------------
+server.tool("search_case", "Search for all documents (judgments, orders, AG opinions) related to a CJEU case number", { caseNumber: z.string().describe("CJEU case number, e.g. C-131/12, T-750/21") }, async ({ caseNumber }) => {
+    const parsed = parseCaseNumber(caseNumber);
+    if (!parsed) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Could not parse case number: "${caseNumber}". Use format like C-131/12 or T-29/10.`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const { prefix, numberPadded, fullYear, formatted } = parsed;
+    const yearStr = String(fullYear);
+    log(`Searching for case ${formatted} (CELEX pattern: 6${yearStr}*${numberPadded})`);
+    try {
+        const docs = await queryCellar(yearStr, numberPadded);
+        // For C- cases, look for linked first-instance T- case
+        let firstInstanceCase = null;
+        if (prefix === "C") {
+            try {
+                const fiCelexNumbers = await queryFirstInstance(yearStr, numberPadded);
+                if (fiCelexNumbers.length > 0) {
+                    // Extract case number from CELEX (e.g. 62012TJ0131 -> T-131/12)
+                    firstInstanceCase = fiCelexNumbers.join(", ");
+                }
+            }
+            catch (e) {
+                log(`First instance query failed: ${e}`);
+            }
+        }
+        if (docs.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No documents found for case ${formatted}.`,
+                    },
+                ],
+            };
+        }
+        const result = {
+            caseNumber: formatted,
+            source: "EU Cellar SPARQL",
+            documents: docs.map((d) => ({
+                type: d.typeLabel,
+                date: d.date,
+                celex: d.celex,
+                title: d.title,
+                pdfAvailable: d.pdfAvailable,
+                htmlAvailable: d.htmlAvailable,
+            })),
+            firstInstanceCase,
+            total: docs.length,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (e) {
+        log(`search_case error: ${e}`);
+        return {
+            content: [
+                { type: "text", text: `Error searching for case ${formatted}: ${e}` },
+            ],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Tool 2: get_document
+// ---------------------------------------------------------------------------
+server.tool("get_document", "Get a CJEU document by CELEX number — either as readable text (for analysis) or as PDF download URLs", {
+    celex: z.string().describe("CELEX number of the document, e.g. 62012CJ0131"),
+    format: z
+        .enum(["text", "pdf_url"])
+        .default("text")
+        .describe("'text' returns the full legal text; 'pdf_url' returns download links"),
+}, async ({ celex, format }) => {
+    log(`get_document: ${celex} format=${format}`);
+    if (format === "pdf_url") {
+        // Look up manifestation URLs
+        const { pdfUrl } = await lookupManifestations(celex);
+        const urls = getPdfUrls(celex, pdfUrl || undefined);
+        const result = {
+            celex,
+            pdfUrls: urls,
+            note: "The first URL (Cellar manifestation) is the most reliable. EUR-Lex may require a browser due to WAF protection.",
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    // format === "text"
+    try {
+        // Look up HTML manifestation URL for this CELEX
+        const { htmlUrl } = await lookupManifestations(celex);
+        const text = await fetchDocumentText(celex, htmlUrl || undefined);
+        if (!text) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Could not retrieve text for CELEX ${celex}. The document may not be available electronically. Try format="pdf_url" for download links.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Truncate if extremely long (>100k chars) to avoid overwhelming context
+        const maxLen = 100_000;
+        const truncated = text.length > maxLen;
+        const output = truncated ? text.slice(0, maxLen) + "\n\n[... truncated, document too long ...]" : text;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `CELEX: ${celex}\n\n${output}`,
+                },
+            ],
+        };
+    }
+    catch (e) {
+        log(`get_document error: ${e}`);
+        return {
+            content: [
+                { type: "text", text: `Error retrieving document ${celex}: ${e}` },
+            ],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Tool 3: search_by_keyword
+// ---------------------------------------------------------------------------
+server.tool("search_by_keyword", "Search CJEU case law by keyword in title/subject matter, with optional year and court filters", {
+    query: z.string().describe("Search keywords, e.g. 'data protection', 'state aid'"),
+    year: z.number().optional().describe("Optional year filter, e.g. 2020"),
+    court: z
+        .enum(["CJ", "GC", "both"])
+        .default("both")
+        .describe("CJ = Court of Justice, GC = General Court, both = all courts"),
+}, async ({ query, year, court }) => {
+    log(`search_by_keyword: "${query}" year=${year ?? "any"} court=${court}`);
+    try {
+        const docs = await searchByKeyword(query, year, court);
+        if (docs.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cases found matching "${query}"${year ? ` in ${year}` : ""}.`,
+                    },
+                ],
+            };
+        }
+        const result = {
+            query,
+            year: year ?? null,
+            court,
+            results: docs.map((d) => ({
+                type: d.typeLabel,
+                date: d.date,
+                celex: d.celex,
+                title: d.title,
+                pdfAvailable: d.pdfAvailable,
+                htmlAvailable: d.htmlAvailable,
+            })),
+            total: docs.length,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (e) {
+        log(`search_by_keyword error: ${e}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error searching for "${query}": ${e}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Start server
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log("CJEU MCP server started");
+}
+main().catch((e) => {
+    process.stderr.write(`Fatal error: ${e}\n`);
+    process.exit(1);
+});

package/dist/sparql.d.ts

@@ -0,0 +1,17 @@
+/** SPARQL query logic — ported from app.py */
+export interface CellarDocument {
+    work: string;
+    typeLabel: string;
+    title: string;
+    date: string;
+    celex: string;
+    expression: string;
+    pdfUrl: string;
+    htmlUrl: string;
+    pdfAvailable: boolean;
+    htmlAvailable: boolean;
+}
+export declare function queryCellar(yearStr: string, numberPadded: string): Promise<CellarDocument[]>;
+export declare function queryCellarByCelex(celex: string): Promise<CellarDocument[]>;
+export declare function queryFirstInstance(yearStr: string, numberPadded: string): Promise<string[]>;
+export declare function searchByKeyword(keywords: string, year?: number, court?: string): Promise<CellarDocument[]>;

package/dist/sparql.js

@@ -0,0 +1,192 @@
+/** SPARQL query logic — ported from app.py */
+import { typeUriToLabel } from "./celex.js";
+const SPARQL_ENDPOINT = "https://publications.europa.eu/webapi/rdf/sparql";
+function val(row, key) {
+    return row[key]?.value ?? "";
+}
+async function runSparql(query) {
+    const url = new URL(SPARQL_ENDPOINT);
+    url.searchParams.set("query", query);
+    const resp = await fetch(url.toString(), {
+        headers: {
+            Accept: "application/sparql-results+json",
+            "User-Agent": "cjeu-mcp/1.0",
+        },
+        signal: AbortSignal.timeout(60_000),
+    });
+    if (!resp.ok) {
+        throw new Error(`SPARQL query failed: ${resp.status} ${resp.statusText}`);
+    }
+    const data = await resp.json();
+    return data.results.bindings;
+}
+function rowsToDocs(rows) {
+    const seen = new Set();
+    const docs = [];
+    for (const row of rows) {
+        const celex = val(row, "celex");
+        if (!celex || seen.has(celex))
+            continue;
+        seen.add(celex);
+        const pdfManif = val(row, "pdfManif");
+        const htmlManif = val(row, "htmlManif");
+        docs.push({
+            work: val(row, "work"),
+            typeLabel: typeUriToLabel(val(row, "type")),
+            title: val(row, "title"),
+            date: val(row, "date"),
+            celex,
+            expression: val(row, "expression"),
+            pdfUrl: pdfManif ? pdfManif + "/DOC_1" : "",
+            htmlUrl: htmlManif ? htmlManif + "/DOC_1" : "",
+            pdfAvailable: !!pdfManif,
+            htmlAvailable: !!htmlManif,
+        });
+    }
+    return docs;
+}
+// Key Cellar ontology notes (discovered empirically):
+//  - expression_belongs_to_work (NOT work_has_expression)
+//  - manifestation_manifests_expression (NOT expression_has_manifestation)
+//  - CONTAINS(STR(...)) required because values are xsd:string
+//  - STR(?hmtype) = "html" required for same reason
+export async function queryCellar(yearStr, numberPadded) {
+    const query = `
+PREFIX cdm: <http://publications.europa.eu/ontology/cdm#>
+
+SELECT DISTINCT ?work ?type ?title ?date ?celex ?expression ?pdfManif ?htmlManif
+WHERE {
+  ?work cdm:resource_legal_id_celex ?celex .
+  ?work cdm:work_has_resource-type ?type .
+  ?work cdm:work_date_document ?date .
+
+  FILTER(CONTAINS(STR(?celex), "${yearStr}") && CONTAINS(STR(?celex), "${numberPadded}"))
+
+  FILTER(?type IN (
+    <http://publications.europa.eu/resource/authority/resource-type/JUDG>,
+    <http://publications.europa.eu/resource/authority/resource-type/ORDER>,
+    <http://publications.europa.eu/resource/authority/resource-type/OPIN_AG>,
+    <http://publications.europa.eu/resource/authority/resource-type/VIEW_AG>
+  ))
+
+  ?expression cdm:expression_belongs_to_work ?work .
+  ?expression cdm:expression_uses_language <http://publications.europa.eu/resource/authority/language/ENG> .
+
+  OPTIONAL { ?expression cdm:expression_title ?title . }
+  OPTIONAL {
+    ?pdfManif cdm:manifestation_manifests_expression ?expression .
+    ?pdfManif cdm:manifestation_type ?pmtype .
+    FILTER(CONTAINS(STR(?pmtype), "pdf"))
+  }
+  OPTIONAL {
+    ?htmlManif cdm:manifestation_manifests_expression ?expression .
+    ?htmlManif cdm:manifestation_type ?hmtype .
+    FILTER(STR(?hmtype) = "xhtml" || STR(?hmtype) = "html")
+  }
+}
+ORDER BY ?type ?date`;
+    return rowsToDocs(await runSparql(query));
+}
+export async function queryCellarByCelex(celex) {
+    const query = `
+PREFIX cdm: <http://publications.europa.eu/ontology/cdm#>
+
+SELECT DISTINCT ?work ?type ?title ?date ?celex ?expression ?pdfManif ?htmlManif
+WHERE {
+  ?work cdm:resource_legal_id_celex ?celex .
+  FILTER(STR(?celex) = "${celex}")
+  ?work cdm:work_has_resource-type ?type .
+  ?work cdm:work_date_document ?date .
+  ?expression cdm:expression_belongs_to_work ?work .
+  ?expression cdm:expression_uses_language <http://publications.europa.eu/resource/authority/language/ENG> .
+  OPTIONAL { ?expression cdm:expression_title ?title . }
+  OPTIONAL {
+    ?pdfManif cdm:manifestation_manifests_expression ?expression .
+    ?pdfManif cdm:manifestation_type ?pmtype .
+    FILTER(CONTAINS(STR(?pmtype), "pdf"))
+  }
+  OPTIONAL {
+    ?htmlManif cdm:manifestation_manifests_expression ?expression .
+    ?htmlManif cdm:manifestation_type ?hmtype .
+    FILTER(STR(?hmtype) = "xhtml" || STR(?hmtype) = "html")
+  }
+}
+LIMIT 5`;
+    return rowsToDocs(await runSparql(query));
+}
+export async function queryFirstInstance(yearStr, numberPadded) {
+    const query = `
+PREFIX cdm: <http://publications.europa.eu/ontology/cdm#>
+
+SELECT DISTINCT ?fiCelex
+WHERE {
+  ?work cdm:resource_legal_id_celex ?celex .
+  FILTER(CONTAINS(STR(?celex), "${yearStr}") && CONTAINS(STR(?celex), "${numberPadded}"))
+  { ?work cdm:case-law_confirms ?firstInstance }
+  UNION
+  { ?work cdm:case-law_annuls ?firstInstance }
+  UNION
+  { ?work cdm:case-law_confirms_partially ?firstInstance }
+  ?firstInstance cdm:resource_legal_id_celex ?fiCelex .
+}`;
+    const rows = await runSparql(query);
+    const celexSet = new Set();
+    for (const row of rows) {
+        const c = val(row, "fiCelex");
+        if (c)
+            celexSet.add(c);
+    }
+    return [...celexSet];
+}
+export async function searchByKeyword(keywords, year, court) {
+    const yearFilter = year
+        ? `FILTER(CONTAINS(STR(?date), "${year}"))`
+        : "";
+    let courtFilter = "";
+    if (court === "CJ") {
+        courtFilter = `FILTER(CONTAINS(STR(?celex), "CJ") || CONTAINS(STR(?celex), "CC"))`;
+    }
+    else if (court === "GC") {
+        courtFilter = `FILTER(CONTAINS(STR(?celex), "TJ") || CONTAINS(STR(?celex), "TF"))`;
+    }
+    // Escape special SPARQL regex characters in keywords
+    const escaped = keywords.replace(/([.*+?^${}()|[\]\\])/g, "\\\\$1");
+    const query = `
+PREFIX cdm: <http://publications.europa.eu/ontology/cdm#>
+
+SELECT DISTINCT ?work ?type ?title ?date ?celex ?expression ?pdfManif ?htmlManif
+WHERE {
+  ?work cdm:resource_legal_id_celex ?celex .
+  ?work cdm:work_has_resource-type ?type .
+  ?work cdm:work_date_document ?date .
+
+  FILTER(?type IN (
+    <http://publications.europa.eu/resource/authority/resource-type/JUDG>,
+    <http://publications.europa.eu/resource/authority/resource-type/ORDER>,
+    <http://publications.europa.eu/resource/authority/resource-type/OPIN_AG>,
+    <http://publications.europa.eu/resource/authority/resource-type/VIEW_AG>
+  ))
+
+  ?expression cdm:expression_belongs_to_work ?work .
+  ?expression cdm:expression_uses_language <http://publications.europa.eu/resource/authority/language/ENG> .
+  ?expression cdm:expression_title ?title .
+  FILTER(REGEX(STR(?title), "${escaped}", "i"))
+
+  ${yearFilter}
+  ${courtFilter}
+
+  OPTIONAL {
+    ?pdfManif cdm:manifestation_manifests_expression ?expression .
+    ?pdfManif cdm:manifestation_type ?pmtype .
+    FILTER(CONTAINS(STR(?pmtype), "pdf"))
+  }
+  OPTIONAL {
+    ?htmlManif cdm:manifestation_manifests_expression ?expression .
+    ?htmlManif cdm:manifestation_type ?hmtype .
+    FILTER(STR(?hmtype) = "xhtml" || STR(?hmtype) = "html")
+  }
+}
+ORDER BY DESC(?date)
+LIMIT 20`;
+    return rowsToDocs(await runSparql(query));
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "cjeu-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for accessing EU Court of Justice case law — search cases, read judgments, AG opinions, and orders",
+  "type": "module",
+  "bin": {
+    "cjeu-mcp": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["mcp", "cjeu", "eu-law", "court-of-justice", "legal", "case-law"],
+  "license": "MIT",
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "cheerio": "^1.0.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  }
+}