model-metadata-central 0.2.0__tar.gz

model_metadata_central-0.2.0/.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+.pytest_cache
+
+node_modules
+dist

model_metadata_central-0.2.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: model-metadata-central
+Version: 0.2.0
+Summary: Typed registry of LLM model metadata for Python — context windows, pricing, provider routing.
+Project-URL: Homepage, https://github.com/InterwebAlchemy/model-metadata-central
+Project-URL: Repository, https://github.com/InterwebAlchemy/model-metadata-central
+Project-URL: Issues, https://github.com/InterwebAlchemy/model-metadata-central/issues
+Author-email: Eric Allen <era@lakera.ai>
+License-Expression: MIT
+Keywords: anthropic,context-window,language model,llm,metadata,openai,pricing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2.0
+Requires-Dist: pyyaml<7,>=6.0
+Description-Content-Type: text/markdown
+
+# model-metadata-central
+
+Typed registry of LLM model metadata for Python — context windows, pricing, provider routing.
+
+```sh
+pip install model-metadata-central
+```
+
+## Usage
+
+### Full registry
+
+```python
+from model_metadata_central import get_all_models, get_all_providers
+
+models = get_all_models()
+for model in models:
+    print(f"{model['model_name']}: {model['context_window']} context")
+```
+
+### Look up a single model
+
+```python
+from model_metadata_central import get_model
+
+model = get_model("gpt-4o")
+if model:
+    print(model["context_window"])          # 128000
+    print(model["cost_per_token"])          # {"input": 0.000005, "output": 0.000015}
+```
+
+### Filter by provider
+
+```python
+from model_metadata_central import get_models_by_provider
+
+anthropic = get_models_by_provider("anthropic")
+openrouter = get_models_by_provider("openrouter")
+```
+
+### Provider routing
+
+```python
+from model_metadata_central import get_provider_model_id, get_provider
+
+# Get the model ID for a specific provider
+openai_id = get_provider_model_id("gpt-4o", "openai")           # "gpt-4o"
+orouter_id = get_provider_model_id("gpt-4o", "openrouter")     # "openai/gpt-4o"
+
+# Get provider config
+provider = get_provider("openai")
+print(provider["base_url"])    # "https://api.openai.com/v1"
+print(provider["auth_type"])    # "api_key"
+```
+
+### Named model constants
+
+```python
+from model_metadata_central import GPT_4_O, CLAUDE_OPUS_4_7
+
+# Fully typed dict — bundlers exclude the rest
+print(GPT_4_O["context_window"])
+```
+
+## API
+
+| Function | Returns | Description |
+|---|---|---|
+| `get_model(id)` | `dict \| None` | Lookup by model_id |
+| `get_all_models()` | `list[dict]` | All models |
+| `get_models_by_provider(provider_id)` | `list[dict]` | Filter by provider |
+| `get_model_on_provider(provider_id, provider_model_id=None)` | `dict \| None` | Find model on a specific provider |
+| `get_provider(id)` | `dict \| None` | Provider config |
+| `get_all_providers()` | `list[dict]` | All providers |
+| `get_provider_model_id(model_id, provider_id)` | `str \| None` | Provider-specific model ID |
+
+## Data
+
+- Registry pre-compiled from `models/*.yaml` at install/build time
+- 74 models across 17 providers
+- Prices are in USD per token
+
+## Schema
+
+Matches the JSON Schema definitions in the repo root.

model_metadata_central-0.2.0/README.md

@@ -0,0 +1,85 @@
+# model-metadata-central
+
+Typed registry of LLM model metadata for Python — context windows, pricing, provider routing.
+
+```sh
+pip install model-metadata-central
+```
+
+## Usage
+
+### Full registry
+
+```python
+from model_metadata_central import get_all_models, get_all_providers
+
+models = get_all_models()
+for model in models:
+    print(f"{model['model_name']}: {model['context_window']} context")
+```
+
+### Look up a single model
+
+```python
+from model_metadata_central import get_model
+
+model = get_model("gpt-4o")
+if model:
+    print(model["context_window"])          # 128000
+    print(model["cost_per_token"])          # {"input": 0.000005, "output": 0.000015}
+```
+
+### Filter by provider
+
+```python
+from model_metadata_central import get_models_by_provider
+
+anthropic = get_models_by_provider("anthropic")
+openrouter = get_models_by_provider("openrouter")
+```
+
+### Provider routing
+
+```python
+from model_metadata_central import get_provider_model_id, get_provider
+
+# Get the model ID for a specific provider
+openai_id = get_provider_model_id("gpt-4o", "openai")           # "gpt-4o"
+orouter_id = get_provider_model_id("gpt-4o", "openrouter")     # "openai/gpt-4o"
+
+# Get provider config
+provider = get_provider("openai")
+print(provider["base_url"])    # "https://api.openai.com/v1"
+print(provider["auth_type"])    # "api_key"
+```
+
+### Named model constants
+
+```python
+from model_metadata_central import GPT_4_O, CLAUDE_OPUS_4_7
+
+# Fully typed dict — bundlers exclude the rest
+print(GPT_4_O["context_window"])
+```
+
+## API
+
+| Function | Returns | Description |
+|---|---|---|
+| `get_model(id)` | `dict \| None` | Lookup by model_id |
+| `get_all_models()` | `list[dict]` | All models |
+| `get_models_by_provider(provider_id)` | `list[dict]` | Filter by provider |
+| `get_model_on_provider(provider_id, provider_model_id=None)` | `dict \| None` | Find model on a specific provider |
+| `get_provider(id)` | `dict \| None` | Provider config |
+| `get_all_providers()` | `list[dict]` | All providers |
+| `get_provider_model_id(model_id, provider_id)` | `str \| None` | Provider-specific model ID |
+
+## Data
+
+- Registry pre-compiled from `models/*.yaml` at install/build time
+- 74 models across 17 providers
+- Prices are in USD per token
+
+## Schema
+
+Matches the JSON Schema definitions in the repo root.

model_metadata_central-0.2.0/model_metadata_central/__init__.py

@@ -0,0 +1,115 @@
+from model_metadata_central.lib import (
+    get_all_models,
+    get_metadata,
+    get_model,
+    get_model_on_provider,
+    get_models,
+    get_models_by_provider,
+)
+from model_metadata_central.utils.exceptions import ModelMetadataNotFoundError
+
+__all__ = [
+    "get_model",
+    "get_all_models",
+    "get_models",
+    "get_models_by_provider",
+    "get_model_on_provider",
+    "get_metadata",
+    "get_provider",
+    "get_all_providers",
+    "get_provider_model_id",
+    "ModelMetadataNotFoundError",
+    # Named model constants — kept in sync with models/*.yaml
+    "GPT_4_O",
+    "GPT_4_O_MINI",
+    "GPT_4_5",
+    "GPT_5_5",
+    "GPT_5_5_PRO",
+    "GPT_5_4_IMAGE_2",
+    "GPT_3_5_TURBO",
+    "GPT_3_5_TURBO_INSTRUCT",
+    "GPT_4",
+    "GPT_4_32K",
+    "O3",
+    "O4_MINI",
+    "CLAUDE_OPUS_4_7",
+    "CLAUDE_OPUS_4_6_FAST",
+    "CLAUDE_SONNET_4_2",
+    "CLAUDE_OPUS_LATEST",
+    "CLAUDE_HAIKU_4",
+    "GEMINI_2_5_PRO",
+    "GEMINI_2_5_FLASH",
+    "GEMINI_2_0_FLASH",
+    "GEMMA_4_31B_IT",
+    "GEMMA_4_26B_A4B_IT",
+    "DEEPSEEK_V4_PRO",
+    "DEEPSEEK_V4_FLASH",
+    "DEEPSEEK_CODER_V4",
+    "GROK_4_2",
+    "GROK_4_2_MULTI_AGENT",
+    "KIMI_K2_6",
+    "KIMI_V3",
+    "QWEN_3_6_PLUS",
+    "QWEN_3_6_FLASH",
+    "MISTRAL_7B",
+    "MISTRAL_7B_INSTRUCT",
+]
+
+# Named model constants — import only what you need
+GPT_4_O = get_model("gpt-4o")
+GPT_4_O_MINI = get_model("gpt-4o-mini")
+GPT_4_5 = get_model("gpt-4.5")
+GPT_5_5 = get_model("gpt-5.5")
+GPT_5_5_PRO = get_model("gpt-5.5-pro")
+GPT_5_4_IMAGE_2 = get_model("gpt-5.4-image-2")
+GPT_3_5_TURBO = get_model("gpt-3.5-turbo")
+GPT_3_5_TURBO_INSTRUCT = get_model("gpt-3.5-turbo-instruct")
+GPT_4 = get_model("gpt-4")
+GPT_4_32K = get_model("gpt-4-32k")
+O3 = get_model("o3")
+O4_MINI = get_model("o4-mini")
+CLAUDE_OPUS_4_7 = get_model("claude-opus-4-7")
+CLAUDE_OPUS_4_6_FAST = get_model("claude-opus-4-6-fast")
+CLAUDE_SONNET_4_2 = get_model("claude-sonnet-4-2")
+CLAUDE_OPUS_LATEST = get_model("claude-opus-latest")
+CLAUDE_HAIKU_4 = get_model("claude-haiku-4")
+GEMINI_2_5_PRO = get_model("gemini-2.5-pro")
+GEMINI_2_5_FLASH = get_model("gemini-2.5-flash")
+GEMINI_2_0_FLASH = get_model("gemini-2.0-flash")
+GEMMA_4_31B_IT = get_model("gemma-4-31b-it")
+GEMMA_4_26B_A4B_IT = get_model("gemma-4-26b-a4b-it")
+DEEPSEEK_V4_PRO = get_model("deepseek-v4-pro")
+DEEPSEEK_V4_FLASH = get_model("deepseek-v4-flash")
+DEEPSEEK_CODER_V4 = get_model("deepseek-coder-v4")
+GROK_4_2 = get_model("grok-4.2")
+GROK_4_2_MULTI_AGENT = get_model("grok-4.2-multi-agent")
+KIMI_K2_6 = get_model("kimi-k2.6")
+KIMI_V3 = get_model("kimi-v3")
+QWEN_3_6_PLUS = get_model("qwen3.6-plus")
+QWEN_3_6_FLASH = get_model("qwen3.6-flash")
+MISTRAL_7B = get_model("mistral-7b")
+MISTRAL_7B_INSTRUCT = get_model("mistral-7b-instruct")
+
+
+# Provider helpers
+def get_provider(provider_id: str) -> dict | None:
+    """Get provider configuration by provider_id, or None if not found."""
+    from model_metadata_central.utils.load_provider import load_provider
+    return load_provider(provider_id)
+
+
+def get_all_providers() -> list[dict]:
+    """Get all providers."""
+    from model_metadata_central._registry import PROVIDERS
+    return list(PROVIDERS)
+
+
+def get_provider_model_id(model_id: str, provider_id: str) -> str | None:
+    """Get the model_id as used by a specific provider."""
+    model = get_model(model_id)
+    if model is None:
+        return None
+    for p in model.get("providers") or []:
+        if p.get("provider_id") == provider_id:
+            return p.get("model_id_on_provider")
+    return None

model_metadata_central-0.2.0/model_metadata_central/_registry.py

@@ -0,0 +1,22 @@
+"""Loader for the bundled JSON registries built by scripts/build_registry.py."""
+import json
+from pathlib import Path
+
+_PKG_DIR = Path(__file__).resolve().parent
+
+
+def _load(name: str) -> list[dict]:
+    path = _PKG_DIR / name
+    if not path.exists():
+        raise RuntimeError(
+            f"Bundled {name} is missing. Run "
+            "`uv run python scripts/build_registry.py` to generate it."
+        )
+    return json.loads(path.read_text())
+
+
+MODELS: list[dict] = _load("registry.json")
+PROVIDERS: list[dict] = _load("providers.json")
+
+MODELS_BY_ID: dict[str, dict] = {m["model_id"]: m for m in MODELS}
+PROVIDERS_BY_ID: dict[str, dict] = {p["provider_id"]: p for p in PROVIDERS}

model_metadata_central-0.2.0/model_metadata_central/generated/__init__.py

@@ -0,0 +1,4 @@
+# Re-export for convenience
+from .models import ModelMetadata, ProviderMetadata
+
+__all__ = ["ModelMetadata", "ProviderMetadata"]

model_metadata_central-0.2.0/model_metadata_central/generated/models.py

@@ -0,0 +1,44 @@
+# Generated from JSON Schema — do not edit manually
+
+from __future__ import annotations
+
+from typing import Any, Literal
+from pydantic import BaseModel, Field
+
+class Provider_reference(BaseModel):
+    provider_id: str
+    model_id_on_provider: str | None = None
+
+class Tokenizer_config(BaseModel):
+    family: Literal['tiktoken', 'tekken', 'sentencepiece', 'huggingface', 'other', 'unknown']
+    name: str | None = None
+
+class ModelMetadata(BaseModel):
+    """Generated from model-metadata.schema.json"""
+    model_id: str
+    model_name: str | None = None
+    model_provider: str | None = None
+    model_description: str | None = None
+    model_info: str | None = None
+    model_version: str | None = None
+    model_type: Literal['chat', 'completion', 'embedding']
+    context_window: float
+    max_tokens: float | None = None
+    cost_per_token: Any | None = None
+    knowledge_cutoff: str | None = None
+    tokenizer: Tokenizer_config | None = None
+    tuning: list | None = None
+    deprecated: bool | None = None
+    providers: list | None = None
+
+class ProviderMetadata(BaseModel):
+    """Generated from provider.schema.json"""
+    provider_id: str
+    name: str
+    website_url: str | None = None
+    api_type: Literal['openai_compatible', 'anthropic', 'openai', 'other']
+    base_url: str | None = None
+    auth_type: Literal['api_key', 'bearer', 'oauth', 'managed', 'none'] | None = None
+    routing_priority: Literal['direct', 'aggregator', 'both']
+    status: Literal['active', 'deprecated', 'inactive'] | None = None
+    notes: str | None = None

model_metadata_central-0.2.0/model_metadata_central/lib.py

@@ -0,0 +1,58 @@
+from model_metadata_central.utils.get_metadata_models import get_metadata_models
+from model_metadata_central.utils.load_metadata import load_metadata
+
+
+def get_model(model_id: str) -> dict | None:
+    """Get metadata for a specific model by model_id, or None if not found."""
+    return load_metadata(model_id)
+
+
+def get_all_models() -> list[dict]:
+    """
+    Get all models from the registry.
+    """
+    models = get_metadata_models()
+    return [load_metadata(m) for m in models]
+
+
+def get_models_by_provider(provider_id: str) -> list[dict]:
+    """
+    Get all models available on a given provider.
+    """
+    return [
+        m for m in get_all_models()
+        if m.get("providers")
+        and any(p.get("provider_id") == provider_id for p in m["providers"])
+    ]
+
+
+def get_model_on_provider(provider_id: str, provider_model_id: str | None = None) -> dict | None:
+    """
+    Find a model available on a specific provider.
+
+    If provider_model_id is given, match both provider and the model's ID on that provider.
+    Otherwise return the first model found on the provider.
+    """
+    for model in get_all_models():
+        providers = model.get("providers") or []
+        for p in providers:
+            if p.get("provider_id") == provider_id:
+                if provider_model_id is None:
+                    return model
+                if p.get("model_id_on_provider") == provider_model_id:
+                    return model
+    return None
+
+
+def get_metadata() -> dict[str, dict]:
+    """
+    Get metadata for all models as a dict keyed by model_id.
+    """
+    return {m["model_id"]: m for m in get_all_models()}
+
+
+def get_models() -> list[str]:
+    """
+    Get all model_ids. Deprecated: use get_all_models() for typed data.
+    """
+    return get_metadata_models()

model_metadata_central-0.2.0/model_metadata_central/providers.json

@@ -0,0 +1,189 @@
+[
+  {
+    "provider_id": "anthropic",
+    "name": "Anthropic",
+    "website_url": "https://anthropic.com",
+    "api_type": "anthropic",
+    "base_url": "https://api.anthropic.com/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for Claude models. Uses Anthropic's own API protocol."
+  },
+  {
+    "provider_id": "cloudflare",
+    "name": "Cloudflare Workers AI",
+    "website_url": "https://developers.cloudflare.com/workers-ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.cloudflare.com/client/v4",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Edge inference via Cloudflare Workers AI. Account-scoped model routes use /accounts/{account_id}/ai/run/{model}; OpenAI-compatible routes use /accounts/{account_id}/ai/v1."
+  },
+  {
+    "provider_id": "deepseek",
+    "name": "DeepSeek",
+    "website_url": "https://deepseek.com",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.deepseek.com/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for DeepSeek V4 and Coder models."
+  },
+  {
+    "provider_id": "google",
+    "name": "Google AI",
+    "website_url": "https://ai.google",
+    "api_type": "openai_compatible",
+    "base_url": "https://generativelanguage.googleapis.com/v1beta",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for Gemini, Gemma, and Lyria models via Vertex AI or AI Studio."
+  },
+  {
+    "provider_id": "groq",
+    "name": "Groq",
+    "website_url": "https://console.groq.com",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.groq.com/openai/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "High-speed inference provider. Good for latency-sensitive applications. Popular for Llama and Mixtral models."
+  },
+  {
+    "provider_id": "lmstudio",
+    "name": "LM Studio",
+    "website_url": "https://lmstudio.ai",
+    "api_type": "openai_compatible",
+    "base_url": "http://localhost:1234/v1",
+    "auth_type": "none",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Local inference GUI and API server for GGUF/GGML models. Similar API to Ollama. Authentication disabled by default."
+  },
+  {
+    "provider_id": "localai",
+    "name": "LocalAI",
+    "website_url": "https://localai.io",
+    "api_type": "openai_compatible",
+    "base_url": "http://localhost:8080/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Self-hosted inference engine. Supports many open models via ggml/gguf. Often used in Kubernetes/ Docker stacks. Authentication may be bearer token or disabled depending on config."
+  },
+  {
+    "provider_id": "minimax",
+    "name": "MiniMax",
+    "website_url": "https://platform.minimax.io",
+    "api_type": "anthropic",
+    "base_url": "https://api.minimax.io/anthropic",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for MiniMax text models. Anthropic-compatible API is recommended and supports streaming plus interleaved thinking; MiniMax also exposes OpenAI-compatible text APIs."
+  },
+  {
+    "provider_id": "mistralai",
+    "name": "Mistral AI",
+    "website_url": "https://mistral.ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.mistral.ai/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for Mistral's own models including Mistral Small, Medium, Large, and Codestral."
+  },
+  {
+    "provider_id": "moonshotai",
+    "name": "Moonshot AI",
+    "website_url": "https://moonshot.ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.moonshotai.com/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for Kimi models."
+  },
+  {
+    "provider_id": "nvidia",
+    "name": "NVIDIA NIM",
+    "website_url": "https://build.nvidia.com",
+    "api_type": "openai_compatible",
+    "base_url": "https://integrate.api.nvidia.com/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "NVIDIA NIM API catalog for hosted and deployable NVIDIA/open model inference, including Nemotron."
+  },
+  {
+    "provider_id": "ollama",
+    "name": "Ollama",
+    "website_url": "https://ollama.com",
+    "api_type": "openai_compatible",
+    "base_url": "http://localhost:11434/v1",
+    "auth_type": "none",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Local inference runtime for macOS, Linux, and Windows. Serves quantized GGUF models. Authentication disabled by default; configure .env/ollama for credentials in production."
+  },
+  {
+    "provider_id": "openai",
+    "name": "OpenAI",
+    "website_url": "https://openai.com",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.openai.com/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "The primary provider for OpenAI models including GPT-4, GPT-5, and o-series."
+  },
+  {
+    "provider_id": "openrouter",
+    "name": "OpenRouter",
+    "website_url": "https://openrouter.ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://openrouter.ai/api/v1",
+    "auth_type": "api_key",
+    "routing_priority": "aggregator",
+    "status": "active",
+    "notes": "Aggregator that routes to multiple providers. Useful for model comparison and failover. Access models from OpenAI, Anthropic, Google, DeepSeek and more via a unified API."
+  },
+  {
+    "provider_id": "qwen",
+    "name": "Qwen",
+    "website_url": "https://qwen.ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for Qwen models via Alibaba Cloud DashScope."
+  },
+  {
+    "provider_id": "x-ai",
+    "name": "xAI",
+    "website_url": "https://x.ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.x.ai/v1",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for Grok models."
+  },
+  {
+    "provider_id": "zai",
+    "name": "Z.AI",
+    "website_url": "https://z.ai",
+    "api_type": "openai_compatible",
+    "base_url": "https://api.z.ai/api/paas/v4",
+    "auth_type": "api_key",
+    "routing_priority": "direct",
+    "status": "active",
+    "notes": "Primary provider for GLM models. OpenAI-compatible API endpoint for Z.AI/Zhipu model access."
+  }
+]