What new PyPI packages are made of

Published 14 November 2026 · Data as of 13 November 2026

Scripts and results for this post on GitHub

py-code.org reads the code in the latest release of PyPI projects and records every module, function and class it imports. In this post, "new packages" means the latest release of each project released between 13 November 2025 and 13 November 2026: 335,167 projects. A project counts if it had any release in that year, so older projects with a recent release are included.

We counted which of these projects import six LLM SDKs, the MCP SDK, the three main HTTP clients and the two pydantic validator APIs. The HTTP and pydantic comparisons use all 354,763 indexed projects: the 335,167 above plus the most downloaded projects whose latest release is older. We left out each library's own add-on packages, such as the many langchain-* integrations and mcp-* servers, so every count shows projects built on top of the library.

The short answer

Python LLM libraries: at most 8.4% of projects in any month

We counted six LLM SDKs: openai, anthropic, litellm, langchain (any module whose name starts with langchain), google-genai (google.genai) and ollama. 22,563 of the 335,167 new packages import at least one of them, which is 6.7%. The MCP SDK is not in this count; the next section covers it.

By month of latest release, the share was 5.0% in November 2025, between 8.2% and 8.4% from March to May 2026, and 5.7% in September and October 2026.

The MCP Python SDK is imported by more projects than openai (20,013 vs 12,096)

The MCP Python SDK is the official library for the Model Context Protocol, which lets AI apps call tools and read data from other programs. It is imported as mcp. We count a project when its own code imports mcp. A project's own modules are never counted, so a package that ships its own module named mcp does not count as a user of itself.

Among the 335,167 new packages:

• mcp: 20,013 projects (6.0%)
• openai: 12,096 (3.6%)
• anthropic: 7,718 (2.3%)
• langchain: 6,721 (2.0%)
• google-genai: 3,409, litellm: 2,971 and ollama: 1,252

The MCP SDK alone is in 20,013 projects, against 22,563 that use any of the six LLM SDKs, each counted once.

LangChain is also the most imported agent framework. The AI agent frameworks post compares it with 24 others, including LangGraph, LlamaIndex and CrewAI, across all indexed projects. That post counts 6,779 projects for LangChain, not 6,721, because it also counts older projects. Few LLM projects trace their calls: of all indexed projects that use an LLM SDK or framework, only 4.8% import an observability SDK such as Langfuse or LangSmith, as the LLM observability SDKs post shows.

requests vs httpx vs aiohttp: httpx is slightly behind requests

Across all 354,763 indexed projects, 88,302 import at least one of requests, httpx or aiohttp. Of those 88,302 projects:

• requests: 45,752 projects (51.8%)
• httpx: 41,112 projects (46.6%), about 10% fewer than requests
• aiohttp: 9,548 projects (10.8%)

A project can import more than one of the three, so the shares add up to more than 100%.

Weighted by downloads, requests leads by more. The 88,302 projects had 7.3 billion downloads in the 30 days before the scan. Projects that import requests account for 73.6% of those downloads, aiohttp for 49.9% and httpx for 26.4%. These shares overlap too, because a project can import more than one library. Download counts exist only for the 60,000 most downloaded projects, and the rest count as zero, so this measure reflects the large, established packages.

pydantic v1 vs v2: 23,696 projects use only v2 validators, 465 only v1

pydantic v2 replaced the @validator and @root_validator decorators with @field_validator and @model_validator, and the pydantic migration guide marks the old ones as deprecated. So the decorators show which API a project's code is written for. Of the 58,358 indexed projects that import pydantic:

• 23,696 use only the v2 decorators (40.6%)
• 465 use only the v1 decorators (0.8%)
• 619 use both
• 563 import pydantic.v1, the copy of the v1 API that pydantic v2 ships for old code. We count these separately, as neither v1 nor v2 use.

The other projects import pydantic but use neither kind of validator decorator.

By downloads the gap looks smaller, but two projects dominate the numbers. v2-only projects account for 42.8% of the 3.0 billion monthly downloads of pydantic users, and v1-only projects for 14.6%. huggingface-hub and openai make up 96% of those v1-only downloads. openai uses root_validator only in code that runs when pydantic v1 is installed, and huggingface-hub imports validator only to check that pydantic can be imported.

How to run these queries yourself

There are four ways, from quickest to most exact: the search on py-code.org, the command-line tool, the SQL console on Hugging Face in your browser, and DuckDB on your own computer. Only DuckDB, and the scripts below it, read the exact snapshot this post used.

On py-code.org

Each finding above has a search page. The search covers all 354,763 indexed projects, and includes each library's own packages, so its counts for the SDKs are higher than the counts for new packages in this post.

• Packages that use mcp.server and packages that import openai
• Packages that import httpx and packages that import requests
• Packages that use pydantic.field_validator and packages that use pydantic.validator

From a terminal or Claude Code

The py-code-org command-line tool runs the same lookup. This lists the most downloaded packages that use httpx.AsyncClient, with the file and line where each one first uses it:

$ uvx py-code-org who-uses httpx.AsyncClient

To let Claude Code look names up while you work, add the MCP server:

$ claude mcp add py-code -- uvx py-code-org mcp

In your browser, on Hugging Face

The full index is a dataset of Parquet files on Hugging Face, and its SQL console runs DuckDB inside your browser. You need no account and nothing installed. Open the SDK query in the console: the link fills in the query below and runs it. The first run can stop with "Table with name refs does not exist", because it starts before the tables have loaded. Click Run Query again: the console then loads refs and projects and runs the query. To type a query yourself:

1. Open the dataset viewer and click SQL Console.
2. Under Subsets and Splits, click refs and projects to load them as tables. Then write the query using the subsets as table names: refs has one row per name a project uses (project, name, module), and projects has one row per project (project, version, upload_time, downloads_30d and more).
3. Click Run Query.

SELECT sdk, count(DISTINCT project) AS projects
FROM (
  SELECT project,
         CASE WHEN module LIKE 'langchain%' THEN 'langchain'
              WHEN module = 'google' THEN 'google-genai'
              ELSE module END AS sdk
  FROM refs
  WHERE module IN ('openai', 'anthropic', 'litellm', 'ollama', 'mcp')
     OR module LIKE 'langchain%'
     OR name = 'google.genai' OR name LIKE 'google.genai.%'
)
JOIN projects USING (project)
WHERE upload_time >= '2025-11-13'
  -- leave out each SDK's own packages (langchain-*, mcp-*) and the iflow-mcp copies
  AND NOT starts_with(lower(project), 'iflow-mcp')
  AND NOT (replace(replace(lower(project), '_', '-'), '.', '-') = sdk
           OR starts_with(replace(replace(lower(project), '_', '-'), '.', '-'), sdk || '-'))
GROUP BY sdk
ORDER BY projects DESC;

In our tests the first run took 3 to 4 minutes, most of it loading the 40 million rows of refs into the browser. Once the data had loaded, the query itself took 5 seconds.

With DuckDB, on the exact snapshot

DuckDB can read the same Parquet files from Hugging Face in place. The @9d81d70d… in each path pins the 13 November 2026 build, so this query always gives the numbers in the SDK chart:

SELECT sdk, count(DISTINCT project) AS projects
FROM (
  SELECT project,
         CASE WHEN module LIKE 'langchain%' THEN 'langchain'
              WHEN module = 'google' THEN 'google-genai'
              ELSE module END AS sdk
  FROM 'hf://datasets/pypi-data/py-code@9d81d70d6519d77f4dee4811b3e3a5d88379c17d/refs.parquet'
  WHERE module IN ('openai', 'anthropic', 'litellm', 'ollama', 'mcp')
     OR module LIKE 'langchain%'
     OR name = 'google.genai' OR name LIKE 'google.genai.%'
)
JOIN 'hf://datasets/pypi-data/py-code@9d81d70d6519d77f4dee4811b3e3a5d88379c17d/projects.parquet' USING (project)
WHERE upload_time >= '2025-11-13'
  -- leave out each SDK's own packages (langchain-*, mcp-*) and the iflow-mcp copies
  AND NOT starts_with(lower(project), 'iflow-mcp')
  AND NOT (replace(replace(lower(project), '_', '-'), '.', '-') = sdk
           OR starts_with(replace(replace(lower(project), '_', '-'), '.', '-'), sdk || '-'))
GROUP BY sdk
ORDER BY projects DESC;

Run it in the DuckDB shell, or from Python with duckdb.sql(query).show(). In our test it took about a minute over the network and returned:

┌──────────────┬──────────┐
│     sdk      │ projects │
│   varchar    │  int64   │
├──────────────┼──────────┤
│ mcp          │    20013 │
│ openai       │    12096 │
│ anthropic    │     7718 │
│ langchain    │     6721 │
│ google-genai │     3409 │
│ litellm      │     2971 │
│ ollama       │     1252 │
└──────────────┴──────────┘

Reproduce every number in this post

The scripts behind every number and chart here are in the pypi-data/blog repository, with the results they gave. With DuckDB installed, one command reads the same pinned snapshot from Hugging Face and writes the post's numbers to out/new-packages.json. It took 36 seconds in our test:

$ git clone https://github.com/pypi-data/blog
$ cd blog/new-pypi-packages-imports
$ pip install duckdb
$ python3 blog_data.py

The October check is in the same folder, as october_check.py. It asks PyPI for each sampled project's release history, so its results can change slightly if a project deletes old releases.

How the numbers were counted

• How the code is read. For each project the scanner reads the .py files of its latest release, parses them with Python's ast module without running them, and keeps the imported names, not the code.
• Latest release only. The index keeps one release per project, the latest one, and reads its Python files. Imports in older releases are not counted.
• Months are latest-release months. Counts of projects by the month of their latest release overstate growth: 33,260 projects have their latest release in September 2026 and 56,685 in October. We sampled 300 projects per month and read their full release history from PyPI's JSON API. The estimated number of projects created was 19,011 in August, 22,273 in September and 24,524 in October, and the error bands (two standard errors) of the three months overlap. These estimates cover only projects still in the index.
• Static imports only. The scanner reads import statements and attribute access on imported names. Imports through importlib or __import__, and names reached through variables, are missed.
• Own packages left out. A project whose name is a library's name, or starts with it followed by a hyphen, is not counted for that library: langchain-openai does not count as a LangChain user, and mcp-server-git does not count as an MCP SDK user. This leaves out 973 projects for LangChain and 1,342 for the MCP SDK, and fewer than 70 for each other SDK and HTTP library (228 for pydantic). The same rule is used in the AI agent frameworks and LLM observability SDKs posts.
• Copies left out. We also dropped the 2,144 iflow-mcp* projects from every count. They are copies of other people's MCP servers republished under one prefix, and 1,627 of them are recent projects that import the MCP SDK.
• No other filtering. Every other project with a release in the year counts, including test uploads and very small packages.
• Downloads. Download counts are for the 30 days before the scan, from ClickHouse's public PyPI dataset, and exist only for the 60,000 most downloaded projects.

Frequently asked questions

Sources

• py-code.org dataset on Hugging Face, revision 9d81d70d (13 November 2026)
• pypi-data/py-code, the scanner that builds the index
• pypi-data/blog, the scripts and results for this post
• MCP Python SDK
• pydantic migration guide
• PyPI JSON API
• DuckDB: reading Hugging Face datasets
• ClickHouse PyPI downloads (ClickPy)