European Parliament MCP Server

What is European Parliament MCP Server about?

It implements the Model Context Protocol to expose the full suite of European Parliament Open Data API v2 endpoints as typed MCP tools. The server aggregates, validates, caches, and rate‑limits requests, then returns clean JSON structures that can be consumed by Claude Desktop, VS Code, Cursor, GitHub Copilot, or any MCP‑aware client.

How to use European Parliament MCP Server?

1. Run the server (no installation required):

   npx -y european-parliament-mcp-server
   

2. Configure an MCP client – add a server entry pointing to the npx command. Example for Claude Desktop:

   {
     "mcpServers": {
       "european-parliament": {
         "command": "npx",
         "args": ["-y", "european-parliament-mcp-server"],
         "env": { "EP_API_KEY": "<YOUR_API_KEY>" }
       }
     }
   }
   

3. Call any of the 63 exposed tools (e.g., get_meps, assess_mep_influence, analyze_coalition_dynamics). The server handles Zod validation, caching, and audit‑logging automatically.

Key Features

• Full EP API v2 coverage – 41 core endpoints + 13 feed endpoints.
• 63 MCP tools (including 15 OSINT‑focused intelligence tools).
• Advanced analytics – MEP influence scoring, coalition cohesion, voting anomaly detection, legislative pipeline monitoring, country‑delegation analysis, and more.
• Security‑first design – ISMS‑aligned, GDPR‑by‑design, SLSA Level 3 provenance, rate limiting, LRU caching, and audit logging.
• High test coverage – 80 %+ code coverage, 1 130+ unit tests, 71 E2E tests.
• Comprehensive documentation – auto‑generated TypeDoc HTML & Markdown, coverage reports, and API reference.
• Cross‑language support – usable from any MCP‑aware AI assistant, IDE, or custom client.

Use Cases

• Journalistic research – retrieve up‑to‑date MEP profiles, voting records, and committee activity for AI‑generated news articles.
• Political risk analysis – compute influence scores, detect coalition stress, and forecast legislative bottlenecks.
• Academic studies – batch‑download structured EP data for statistical modeling or network analysis.
• Civic tech portals – power dashboards such as EU Parliament Monitor that present real‑time parliamentary intelligence.
• Compliance monitoring – audit voting patterns and document provenance for transparency initiatives.

FAQ

Q: Do I need an API key? A: The European Parliament Open Data API is publicly accessible, but an EP_API_KEY can be supplied to increase rate limits or access optional endpoints.

Q: Can I run the server behind a firewall? A: Yes. The server only makes outbound HTTPS calls to data.europarl.europa.eu; configure outbound proxy settings if required.

Q: How does caching work? A: Responses are cached in an in‑memory LRU store (500 entries, 15‑minute TTL). Identical requests hit the cache instantly.

Q: What languages are supported for client output? A: The server returns pure JSON; any language that can parse JSON can consume the data.

Q: Is the server compatible with other MCP servers? A: Absolutely. The same MCP client configuration can point to multiple servers (e.g., the Swedish Riksdag MCP server) for cross‑parliament analysis.

📊 Quality Metrics & Documentation

📋 Overview

The European Parliament MCP Server implements the Model Context Protocol (MCP) to provide AI assistants, IDEs, and other MCP clients with structured access to European Parliament open datasets. Access information about MEPs, plenary sessions, committees, legislative documents, and parliamentary questions through a secure, type-safe TypeScript/Node.js implementation.

🎯 Key Features

• 🔌 Full MCP Implementation: 63 tools (9 core + 3 advanced + 15 OSINT + 8 Phase 4 + 15 Phase 5 + 13 feed), 9 Resources, and 7 Prompts
• 🏛️ Complete EP API v2 Coverage: All European Parliament Open Data API endpoints covered
• 🕵️ OSINT Intelligence: MEP influence scoring, coalition analysis, anomaly detection
• 🔒 Security First: ISMS-compliant, GDPR-ready, SLSA Level 3 provenance
• 🚀 High Performance: <200ms API responses, intelligent caching, rate limiting
• 📊 Type Safety: TypeScript strict mode + Zod runtime validation
• 🧪 Well-Tested: 80%+ code coverage, 1130+ unit tests, 71 E2E test cases
• 📚 Complete Documentation: Architecture, TypeDoc API (HTML + Markdown), security guidelines

🌍 Hack23 Political Intelligence Ecosystem

This MCP server is the EU data backbone of Hack23's mission to disrupt parliamentary journalism with AI-generated political intelligence and real-time accountability analysis — increasing democratic transparency through structured open-source intelligence (OSINT) tradecraft applied to public legislative data.

🎯 Vision: AI-Powered Democratic Transparency

Hack23 AB builds open-source intelligence platforms that put rigorous, evidence-based political analysis in the hands of every citizen, journalist, researcher and policymaker. By combining MCP servers, agentic AI newsrooms, and open parliamentary data, we produce automated intelligence products — coalition analysis, voting-pattern decoding, MEP/MP influence scoring, legislative-pipeline forecasting — that previously required well-funded lobbying organisations or in-house policy units to generate.

"Democratising access to political intelligence — what used to require a team of analysts can now be done by any citizen with an AI assistant."

The portfolio is non-partisan, fully open-source (Apache-2.0), operated under the Hack23 ISMS with full ISO 27001:2022 / NIST CSF 2.0 / CIS Controls v8.1 alignment, GDPR-by-design, and architecturally engineered so it cannot be weaponised for partisan influence: equal treatment of all political groups, public-data only, no user accounts, no ads, no tracking.

🧭 The Ecosystem at a Glance

This MCP server's role: the canonical, type-safe TypeScript bridge between the European Parliament Open Data Portal and any MCP-aware AI client (Claude Desktop, VS Code, Cursor, GitHub Copilot) — and the upstream data layer that powers the EU Parliament Monitor newsroom. Every tool is Zod-validated, audit-logged, GDPR-aware, and SLSA Level 3 attested.

🗂️ Portfolio Comparison Matrix

🇪🇺 EU Parliament Monitor — euparliamentmonitor.com

European Parliament Political Intelligence Platform — 🧠 Political intelligence · 🔍 Radical transparency · 🗳️ Democratic accountability · 🤖 AI-generated news in 14 languages

🗳️ Riksdagsmonitor — riksdagsmonitor.com

Swedish Political Intelligence Platform — 🕵️ Political intelligence · 🔍 Democratic transparency · 🤖 AI-generated news · 📊 50+ years of evidence

🕵️ Citizen Intelligence Agency (CIA)

Political transparency platform — Java/Spring data backbone behind Riksdagsmonitor's historical evidence layer

🌍 Shared Across the Portfolio

🔗 Hack23 Portfolio Quick Links

• 🌐 Live platforms — euparliamentmonitor.com · riksdagsmonitor.com · hack23.github.io/cia · hack23.com
• 🧠 Political Intelligence Hubs — EU Parliament · Riksdag
• 📂 Source repositories — European-Parliament-MCP-Server · euparliamentmonitor · riksdagsmonitor · cia · ISMS-PUBLIC
• 📦 npm packages — european-parliament-mcp-server · euparliamentmonitor · riksdagsmonitor
• 📰 Blog & company — Hack23 blog · LinkedIn — Hack23 AB · founder James Pether Sörling, CISSP, CISM
• 🤖 AI-readable wikis — DeepWiki: European-Parliament-MCP-Server · DeepWiki: euparliamentmonitor · DeepWiki: riksdagsmonitor · DeepWiki: cia

🔐 Security & Compliance

🚀 Quick Start

Run with npx (No Installation Required)

npx -y european-parliament-mcp-server

Prerequisites

• Node.js 26.x or higher
• npm 10.x or higher

Installation

Option 1: Install from npm (Recommended)

# Install the package globally
npm install -g european-parliament-mcp-server

# Or install as a dependency in your project
npm install european-parliament-mcp-server

Option 2: Install from source

# Clone the repository
git clone https://github.com/Hack23/European-Parliament-MCP-Server.git
cd European-Parliament-MCP-Server

# Install dependencies
npm install

# Build the project
npm run build

# Run tests
npm test

Usage with MCP Client

Claude Desktop Configuration (npm install)

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "european-parliament": {
      "command": "npx",
      "args": ["european-parliament-mcp-server"],
      "env": {
        "EP_API_KEY": "your-api-key-if-needed"
      }
    }
  }
}

Claude Desktop Configuration (source install)

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "european-parliament": {
      "command": "node",
      "args": ["/path/to/European-Parliament-MCP-Server/dist/index.js"],
      "env": {
        "EP_API_KEY": "your-api-key-if-needed"
      }
    }
  }
}

VS Code Extension

Configure in .vscode/mcp.json:

{
  "servers": {
    "european-parliament": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "european-parliament-mcp-server"]
    }
  }
}

Cursor IDE Configuration

Add to ~/.cursor/mcp.json (or project-level .cursor/mcp.json):

{
  "mcpServers": {
    "european-parliament": {
      "command": "npx",
      "args": ["european-parliament-mcp-server"],
      "env": {}
    }
  }
}

Custom Timeout Configuration

Use --timeout <ms> to override the default 60 s request timeout. This is especially useful in copilot-mcp.json or other contexts where the env field may not reliably propagate:

{
  "args": ["european-parliament-mcp-server", "--timeout", "90000"]
}

Precedence: --timeout CLI arg > EP_REQUEST_TIMEOUT_MS env var > default (60 000 ms).

Note: The procedures/feed and events/feed endpoints automatically use an extended 120 s timeout because these EP API endpoints are significantly slower than others. If you experience timeouts with one-month timeframes, consider using year-based queries (e.g., get_procedures({ year: 2026 })) as a faster alternative.

📚 Documentation

🌐 Documentation Portal

📖 Complete Documentation Site - Live documentation portal with:

• 📖 API Reference (HTML) - TypeDoc generated API documentation with search, hierarchy navigation, and full type information
• 📖 API Reference (Markdown) - SEO-friendly Markdown API documentation
• 📊 Coverage Reports - Test coverage analysis
• ✅ Test Reports - Unit and E2E test results
• 🔐 Build Attestations - SLSA Level 3 provenance
• 📦 SBOM - Software Bill of Materials
• 🗺️ Sitemap - Auto-generated sitemap for search engines

💡 Note: Documentation is automatically generated and committed with each release via npm run docs:build

Generated API Documentation

The API documentation is generated using TypeDoc with the following plugins:

Generate documentation locally:

npm run docs          # HTML API docs → docs/api/
npm run docs:md       # Markdown API docs → docs/api-markdown/
npm run docs:build    # Full documentation build (HTML + MD + coverage + test reports)

Core Documentation

• API Usage Guide - Complete tool documentation with examples
• Architecture Diagrams - C4 model diagrams and data flows
• Troubleshooting Guide - Common issues and solutions
• Developer Guide - Development workflow and contributing
• Deployment Guide - Claude Desktop, VS Code, Docker setup
• Performance Guide - Optimization strategies
• Documentation as Code Guide - How documentation is generated

Additional Documentation

• ARCHITECTURE.md - Complete architecture and design documentation
• SECURITY.md - Security policy and vulnerability disclosure
• SECURITY_HEADERS.md - API security headers implementation
• docs/SBOM.md - Software Bill of Materials documentation
• CONTRIBUTING.md - Contribution guidelines
• CODE_OF_CONDUCT.md - Community code of conduct
• .github/copilot-instructions.md - Development guidelines for GitHub Copilot
• .github/agents/README.md - Custom GitHub Copilot agents
• .github/skills/README.md - Reusable skill patterns

🏗️ Architecture Overview

Data flow: MCP client sends a tool call → server validates input (Zod) → EP client checks cache → on miss, fetches from EP API (rate-limited) → response cached and returned as structured JSON. All personal data access is audit-logged per GDPR Article 30.

🔌 MCP Tools (63 Total)

63 tools organized by capability — OSINT intelligence first, then analytical, data access, feed endpoints, and reference tools. Every tool includes Zod input validation, caching, and rate limiting.

🗺️ Political Intelligence Coverage Map

🎯 OSINT Intelligence Workflow

🕵️ OSINT Intelligence Tools (15)

📊 Advanced Analysis Tools (4)

👤 MEP Tools (7)

🏛️ Plenary & Meeting Tools (9)

🏢 Committee Tools (2)

📄 Document Tools (7)

⚖️ Legislative Procedure Tools (4)

📡 Feed Tools (13)

Real-time change feeds for monitoring recently updated data across all EP API categories. Per the EP OpenAPI spec, feeds fall into two groups:

• Configurable-window (6 tools): Accept timeframe (today, one-day, one-week, one-month, custom) + optional startDate
• Fixed-window (7 tools): No parameters — return updates from a server-defined default window (typically one month)

Key behaviors:

• All feeds return JSON-LD with data[], @context[], and dataQualityWarnings[]
• Empty feeds (EP API 404 or error-in-body) are converted to empty data[] with a warning — not errors
• get_events_feed and get_procedures_feed always use a minimum 120s timeout because these endpoints are consistently slow
• Fixed-window feeds can be very slow (30–180 s) and often return error-in-body responses
• For configurable feeds, when timeframe is custom, startDate (YYYY-MM-DD) is required

Configurable-window feeds:

Fixed-window feeds (no parameters):

🔧 Server Diagnostics (1)

📖 Complete TypeDoc API documentation → · Markdown API docs →

Common Use Cases

Research a specific MEP:

1. Find MEP: get_meps → {country: "SE"}
2. Get details: get_mep_details → {id: "MEP-123"}
3. Analyze voting: analyze_voting_patterns → {mepId: "MEP-123"}
4. Generate report: generate_report → {reportType: "MEP_ACTIVITY", subjectId: "MEP-123"}

Track legislation:

1. Search documents: search_documents → {keywords: "climate change"}
2. Track procedure: track_legislation → {procedureId: "2024/0001(COD)"}
3. Get voting records: get_voting_records → {topic: "climate"}

Committee analysis:

1. Get committee: get_committee_info → {abbreviation: "ENVI"}
2. List members: get_meps → {committee: "ENVI"}
3. Generate report: generate_report → {reportType: "COMMITTEE_PERFORMANCE", subjectId: "COMM-ENVI"}

OSINT Intelligence analysis:

1. Score MEP influence: assess_mep_influence → {mepId: "MEP-123"}
2. Detect anomalies: detect_voting_anomalies → {mepId: "MEP-123"}
3. Analyze coalitions: analyze_coalition_dynamics → {groupIds: ["EPP", "S&D"]}
4. Compare groups: compare_political_groups → {groupIds: ["EPP", "S&D", "Renew"]}
5. Pipeline status: monitor_legislative_pipeline → {committee: "ENVI"}
6. Country delegation: analyze_country_delegation → {country: "SE"}
7. Political landscape: generate_political_landscape → {}

🎯 More use cases and examples →

📝 MCP Prompts

Pre-built intelligence analysis prompt templates:

📦 MCP Resources

Direct data access via EP resource URIs:

🗺️ Global Political MCP Servers & OSINT Coverage

The European Parliament MCP Server is part of a growing ecosystem of political and government open data MCP servers enabling AI-powered OSINT analysis of democratic institutions worldwide. Below is the most comprehensive directory of political and government MCP servers available.

🏛️ Parliamentary & Legislative MCP Servers

📊 Government Open Data MCP Servers

🌍 Multi-Portal & Generic MCP Servers

🕵️ OSINT Intelligence Capabilities Comparison

💡 The European Parliament MCP Server offers the most comprehensive OSINT intelligence capabilities of any political MCP server, with 63 specialized tools including advanced analytics like coalition stress analysis, voting anomaly detection, cross-tool intelligence correlation, political landscape generation, and precomputed longitudinal statistics. It is the only political MCP server with built-in MCP prompts, resources, and a 5-dimension MEP influence scoring model.

🏛️ European Parliament Datasets

Complete EP API v2 Coverage

All 55 European Parliament Open Data API v2 endpoints are fully covered — 41 core data endpoints, 13 feed endpoints, and 1 optional endpoint (/procedures/{id}/events/{event-id}):

Data Source

• API: https://data.europarl.europa.eu/api/v2/
• Documentation: https://data.europarl.europa.eu/en/developer-corner
• Format: JSON-LD, RDF/XML, Turtle
• License: European Parliament Open Data License

🔒 Security & Compliance

ISMS Compliance

This project aligns with Hack23 AB's Information Security Management System (ISMS):

• ✅ ISO 27001:2022 - Information security management
• ✅ NIST CSF 2.0 - Cybersecurity framework
• ✅ CIS Controls v8.1 - Security best practices
• ✅ GDPR - EU data protection compliance

Security Features

• 🔐 Authentication: API key + OAuth 2.0 (planned)
• 🛡️ Input Validation: Zod schemas for all inputs
• ⚡ Rate Limiting: 100 requests per minute
• 🔒 Security Headers: CSP, HSTS, X-Frame-Options, etc.
• 📝 Audit Logging: All data access logged
• 🔍 Vulnerability Scanning: CodeQL, Dependabot, OSSF Scorecard

Supply Chain Security

This project achieves SLSA Level 3 compliance:

• ✅ Build Provenance - Cryptographic proof of build integrity
• ✅ Attestations - All artifacts cryptographically signed
• ✅ Verification - gh attestation verify <artifact> --owner Hack23 --repo European-Parliament-MCP-Server
• ✅ npm Provenance - Published with provenance for package integrity
• ✅ SBOM - SPDX-format Software Bill of Materials
• ✅ Dependency Review - Automated vulnerability scanning
• ✅ License Compliance - Only MIT, Apache-2.0, BSD, ISC allowed

See ATTESTATIONS.md for verification instructions and security benefits.

📋 Project Classification

Per Hack23 Open Source Policy:

Property	Value
CRA Classification	Non-commercial Open Source Software
Confidentiality
Integrity
Availability

See CRA-ASSESSMENT.md for the full EU Cyber Resilience Act conformity assessment.

🧪 Development

Setup Development Environment

# Install dependencies
npm install

# Run in development mode with auto-reload
npm run dev

# Type checking
npm run type-check

# Linting
npm run lint

# Format code
npm run format

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

Project Structure

European-Parliament-MCP-Server/
├── src/                      # Source code
│   ├── server.ts            # MCP server entry point
│   ├── tools/               # MCP tool implementations
│   ├── resources/           # MCP resource handlers
│   ├── prompts/             # MCP prompt templates
│   ├── clients/             # European Parliament API client
│   ├── schemas/             # Zod validation schemas
│   ├── types/               # TypeScript type definitions
│   └── utils/               # Utility functions
├── tests/                   # Test files
├── .github/                 # GitHub configuration
│   ├── agents/             # Custom Copilot agents
│   ├── skills/             # Reusable skill patterns
│   └── workflows/          # CI/CD workflows
└── docs/                    # Additional documentation

Documentation

📚 Developer Documentation

• JSDoc Coverage Report - Detailed analysis of JSDoc documentation coverage across all source files
• JSDoc Quick Reference - Quick reference guide for writing comprehensive JSDoc comments
• JSDoc Coverage Summary - Executive summary of documentation status and priorities
• JSDoc Coverage Visualization - Visual representation of documentation coverage with charts and graphs

🏗️ Architecture & Design

• Architecture Documentation - System architecture and design patterns
• Data Model - Data structures and type definitions
• API Usage Guide - Guide for using the MCP server API
• EP Political Landscape - 📊 Comprehensive Mermaid visualization of all EP statistics (2004–2026), political compass, coalition dynamics, and OSINT intelligence metrics — all years validated against EP API v2

🧪 Testing & Quality

• Test Coverage Report - Test coverage statistics and analysis
• Developer Guide - Development setup and guidelines
• Performance Guide - Performance optimization strategies

🔒 Security & Compliance

• Security Policy - Vulnerability reporting and security practices
• Security Architecture - Security controls and architecture
• Secure Development Policy - Secure coding standards
• Open Source Policy - Open source compliance guidelines

📦 Deployment & Operations

• Deployment Guide - Production deployment instructions
• Troubleshooting Guide - Common issues and solutions
• NPM Publishing Guide - Package publishing workflow

Testing

# Unit tests
npm test

# Integration tests (requires EP_INTEGRATION_TESTS=true)
EP_INTEGRATION_TESTS=true npm run test:integration

# Integration tests with fixture capture
EP_INTEGRATION_TESTS=true EP_SAVE_FIXTURES=true npm run test:integration

# E2E tests
npm run test:e2e

# Coverage report
npm run test:coverage

# Watch mode
npm run test:watch

Integration Testing: When EP_INTEGRATION_TESTS=true, the integration test suite validates 46 MCP tools against the real European Parliament API endpoints (see INTEGRATION_TESTING.md for the complete 62-tool coverage guide). All tools return real data — no mock or placeholder data is used. Live API tests are disabled by default to respect rate limits (100 req/min).

Code Quality

# Lint code
npm run lint

# Fix linting issues
npm run lint:fix

# Check for unused dependencies
npm run knip

# Security audit
npm audit

# License compliance
npm run test:licenses

🛠️ Troubleshooting

API Rate Limits

Symptom: Requests return 429 Too Many Requests or slow down unexpectedly.

The European Parliament Open Data API enforces rate limits. The MCP server automatically applies a token-bucket rate limiter (100 requests per minute).

Solutions:

# Reduce concurrency — don't call multiple tools in parallel bursts
# Use the built-in cache — repeated identical requests are served from LRU cache
# Add a delay between bulk operations:
# e.g., call get_meps, wait 1 s, then call get_mep_details

# Check current cache stats (if using programmatic access):
const stats = epClient.getCacheStats();
console.log(`Cache hit rate: ${stats.hitRate}%`);

Connectivity Issues

Symptom: ECONNREFUSED, ETIMEDOUT, or Network error from tools.

Solutions:

1. Verify EP API reachability: curl https://data.europarl.europa.eu/api/v2/meps?limit=1
2. Check firewall / proxy settings — the server connects outbound to data.europarl.europa.eu:443
3. Enable retry (default: on) — the client retries transient failures with exponential backoff
4. Review API status at https://data.europarl.europa.eu/en/developer-corner

Installation Problems

Symptom: npm install fails, or node dist/index.js throws import errors.

Solutions:

# Ensure Node.js 26+ is installed
node --version   # Must be >= 26.0.0

# Clear npm cache and reinstall
npm cache clean --force
rm -rf node_modules package-lock.json
npm install

# Rebuild TypeScript output
npm run build

# Verify the package starts correctly
node dist/index.js --version

Symptom: MCP client shows "server not found" or no tools listed.

Solutions:

• Confirm the command path in your MCP client config points to the correct binary
• For npx: ensure european-parliament-mcp-server is in your npm registry
• For node: use the absolute path to dist/index.js
• Check MCP client logs — most clients (Claude Desktop, VS Code) log connection errors

Integration Test Failures

Symptom: Integration tests fail with EP_INTEGRATION_TESTS must be set.

Integration tests are disabled by default to respect API rate limits.

# Enable integration tests explicitly:
EP_INTEGRATION_TESTS=true npm run test:integration

# Capture fresh fixtures for offline testing:
EP_INTEGRATION_TESTS=true EP_SAVE_FIXTURES=true npm run test:integration

TypeScript / Build Errors

Symptom: tsc reports type errors after pulling latest changes.

# Regenerate all types
npm run type-check

# Check for mismatched Node types
npm install  # updates @types/node

# Ensure tsconfig is correct
cat tsconfig.json

Getting Help

• 📋 Open an Issue
• 💬 Start a Discussion
• 📖 Full Troubleshooting Guide
• 🤖 Ask DeepWiki

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for details on:

• Code of conduct
• Development process
• Pull request guidelines
• Coding standards
• Testing requirements

GitHub Copilot Integration

This repository includes custom agents and skills for GitHub Copilot:

• Agents: Specialized AI assistants for development, testing, security, and documentation
• Skills: Reusable patterns for MCP development, security, testing, and performance
• See .github/agents/README.md and .github/skills/README.md

Release Process

We follow Semantic Versioning and use automated release management:

Version Types:

• Major (x.0.0): Breaking changes (e.g., API incompatible changes)
• Minor (0.x.0): New features, backward compatible (e.g., new MCP tools)
• Patch (0.0.x): Bug fixes, security updates, backward compatible

Automated Release Workflow:

1. Develop features in feature branches
2. Create PR with descriptive title using Conventional Commits
3. Labels are automatically applied based on changed files
4. After merge to main, release draft is automatically created
5. Review and publish release (creates git tag automatically)

Release Notes Include:

• Categorized changes by feature area
• Security badges (OpenSSF Scorecard, SLSA)
• Technology stack and compatibility
• ISMS compliance status
• Full changelog link

For detailed workflow documentation, see .github/WORKFLOWS.md.

🤖 AI-Disrupted Intelligence & Future Roadmap

📰 News is dead. Long live intelligence.

While the world's newsrooms race to replace journalists with GPT-powered headline factories — churning out "10 Things the EU Did Today" listicles at the speed of hallucination — we took a different path. Instead of automating the news ticker, we built a political intelligence platform that actually understands what the European Parliament does. Disrupted news generation produces noise; deep political intelligence produces signal. Any chatbot can summarize a press release. It takes 62 MCP tools, 15 OSINT analyzers, and a 5-dimension influence model to tell you which MEP quietly brokered the amendment that changed the directive that reshaped an industry — three months before the newspapers notice.

This is not a news bot. This is parliamentary intelligence infrastructure.

🏗️ Agentic Architecture Overview

This repository is powered by a comprehensive AI-augmented development ecosystem — 14 specialized Copilot agents, 41 reusable skills, and 11 CI/CD workflows — working in concert to maintain, analyze, and evolve the most advanced political MCP server in existence.

📅 Future Advanced Roadmap: 2026–2037

From 62 MCP tools today to a transformative democratic intelligence platform serving all 195 parliamentary systems — powered by the relentless march of AI model generations.

Phase 5: Advanced Intelligence (2026–2027)

Phase 6: AGI Era & Transformative Democracy (2034–2037)

Scenario: AGI or near-AGI systems become available through Amazon Bedrock or successor platforms

🧬 AI Model Evolution Strategy

Assumptions: Anthropic Opus minor updates every ~2.3 months through 2037 (or until successor paradigm). Major version upgrades annually. Competitors (OpenAI, Google, Meta, EU sovereign AI) evaluated at each major release. Architecture must accommodate potential paradigm shifts (quantum AI, neuromorphic computing).

📊 Workflow Count & Capability Projection

Baseline: 11 GitHub Actions workflows today. Projected growth includes AI-generated workflows, scheduled intelligence pipelines, multi-environment deployment chains, and automated OSINT processing — see FUTURE_WORKFLOWS.md for detailed expansion plans.

🔮 Strategic Considerations

🗺️ Extended Roadmap Visualization

📚 Future Architecture Documents

For deep dives into specific evolution tracks, see:

📜 License

This project is licensed under the Apache License 2.0 - see LICENSE.md for details.

🔗 Links

Project Resources

• GitHub Repository
• Issue Tracker
• Discussions
• Security Policy

Hack23 Ecosystem

• 🏢 Hack23 AB — Swedish cybersecurity & open-source intelligence consultancy (blog · LinkedIn)
• 🏛️ EU Parliament Monitor (repo · npm · Political Intelligence Hub · DeepWiki) — daily AI-generated EU parliamentary intelligence in 14 languages, powered by this MCP server
• 🗳️ Riksdagsmonitor (repo · npm · News · Dashboard · DeepWiki) — Swedish Parliament intelligence, 11 agentic workflows, 50+ years of historical evidence
• 🕵️ Citizen Intelligence Agency (CIA) (Pages · DeepWiki) — Java/Spring political-analytics backend, 15 subsystems, 1971–2024 voting & document corpus
• 🛡️ Hack23 ISMS-PUBLIC — public ISO 27001:2022 / NIST CSF 2.0 / CIS Controls v8.1 information-security management system

European Parliament

• Open Data Portal
• Developer Corner
• Data Privacy Policy

MCP Protocol

• MCP Specification
• MCP SDK
• MCP Documentation

MCP Registries

• npm Package — npm registry

Political & Government MCP Servers

• Congress.gov API MCP Server — US Congress data (TypeScript)
• UK Parliament MCP — UK Hansard, members, debates
• Riksdag & Regering MCP — Swedish Parliament data
• Parliament of Poland MCP — Polish Parliament data
• OpenTK MCP — Dutch Parliament (Tweede Kamer) documents
• Knesset MCP — Israeli Parliament data
• CKAN MCP Server — Generic CKAN portal access
• OpenGov MCP Server — Socrata-powered portals

Hack23 ISMS

• ISMS Policies
• Open Source Policy
• Secure Development Policy

🙏 Acknowledgments

• European Parliament for providing open data access
• Model Context Protocol team for the MCP specification
• Hack23 AB for ISMS policies and security standards
• OpenSSF for supply chain security tools
• Contributors who help improve this project