PyPI Packages MCP Server

On the left, you can see our MCP tools are connected to Kiro AI Coding Editor
On the right, the user gives a requirement: ‘build an agent that summarizes stand-up meetings in ≤5 bullet points
Because the requirement mentions OpenAI’s latest Responses API, the agent calls our search_packages tool
Next, the agent calls get_package_metadata for the chosen package,MCP server goes cache-first for speed and falls back to PyPI for freshness
Armed with metadata from package README, the agent creates the client code to use the Responses API (note the client.responses.create(...))

Inspiration

AI models miss new Python packages after training (the “knowledge cutoff”). We wanted a practical way for AI coding agents to use fresh PyPI data, choose compatible versions, and adapt code safely, so developers get accurate help, fewer conflicts, and faster builds.

What it does

Gives agents real-time awareness of package versions, metadata, and dependencies.
Analyzes a project and flags conflicts early.
Searches PyPI, pulls metadata/README, and grounds on version-specific APIs.
Autonomously proposes and applies a package/version, updates the code, and runs tests as the gate; on failure it revises or asks for approval.
Works in a spec-driven flow (specs → code + tests).
Amplifies READMEs/long descriptions: well-authored docs make new APIs discoverable to LLMs.

How we built it

Python 3.8+ MCP server exposing tools:
search_packages, get_package_metadata, analyze_project_dependencies, check_package_compatibility, get_latest_version
Local-first caching with PyPI fallback (JSON API) for freshness.
httpx for async HTTP; pytest for automated tests.
Built and steered in a spec-driven workflow (Kiro as the AI Editor/Coding assistant).

Challenges we ran into

Shifting mindset from “write code” to “write specs”.
Balancing freshness vs. latency (cache vs. live PyPI).
Keeping human-in-the-loop review fast while the agent iterates; ensuring decisions remain tool-grounded.

Accomplishments that we're proud of

Turned a single, clear spec into working tools + tests.
Closed the knowledge-cutoff gap using live PyPI data (agent used a post-training version correctly).
Produced consistent, clean implementations aligned with the spec.
Demonstrated how strong READMEs directly improve agent understanding of new APIs.

What we learned

Spec-driven development accelerates delivery (~20% specs → ~80% code).
Tests are the signal to proceed safely; tool-grounded steps reduce hallucinations vs. prompt-only.
Documentation quality matters, rich READMEs become immediate LLM context.

What's next for PyPI Packages MCP Server

RAG-for-tools: send only relevant slices of metadata/README to the model.
E2E evaluation harness with fixture projects and golden outputs.

Built With

Language: Python 3.8+
Protocol: Model Context Protocol (MCP)
Libraries: httpx, pytest
Data Source: PyPI JSON API
Approach: Local-first caching, spec-driven workflow (Kiro), tests-as-gate

Alignment with HackOmatic 2025

Mission fit: autonomous & adaptive.
The agent analyzes a repo, discovers post-training packages, fetches metadata/README to ground on version-specific APIs, selects a compatible version, edits code, and runs tests as the decision signal. It adapts to live PyPI state and test outcomes, reducing integration risk.

Primary track: Workflow Automation • Secondary: AI Assistants

What HackOmatic asks vs. what we deliver

Functional MVP: MCP server exposing callable tools.
Autonomous component: Version selection + code modification governed by compatibility checks and tests.
Real-world relevance: Addresses the LLM knowledge-cutoff for fast-moving Python ecosystems (uses README/long description, dependencies, versions as additional context letting coding agents provide accurate responses).
Submission assets: demo video; repo with setup, architecture, and stack.

Why it pushes Agentic AI forward
Tool-grounded (MCP) agents act on external state, adapt via tests, and keep pace with packages released after model training.