llm_factories.json

Overview

The llm_factories.json file serves as a comprehensive registry and catalog of large language model (LLM) factories and their associated models. It organizes metadata about various LLM providers (factories) and enumerates the individual LLMs they offer. This data file is designed primarily for systems that need to dynamically discover, configure, or display available LLM services and their capabilities, such as chatbot platforms, AI model marketplaces, or multi-provider LLM orchestration systems.

Each factory entry contains identifying information and a list of the specific LLM models available from that provider, including attributes like model name, supported features/tags, maximum token limits, model type, and tool support. This structured data facilitates automated integration, filtering, selection, and management of models by client applications.

Key Features:

• Lists multiple LLM providers with metadata.

• Details LLM models per provider with attributes for capabilities and usage constraints.

• Supports various model types (chat, embedding, speech2text, tts, image2text, rerank).

• Enables filtering by features (tags), token limits, and tool compatibility.

• Designed as a static JSON catalog for easy loading and parsing.

Structure and Content Description

The JSON file contains a top-level key factory_llm_infos which is an array. Each element of this array represents a distinct "factory" (LLM provider). The structure for each factory is:

{
    "name": "FactoryName",
    "logo": "URL or path to logo (optional)",
    "tags": "Comma-separated features and capabilities",
    "status": "String status indicator (e.g., '1' for active)",
    "llm": [
        {
            "llm_name": "ModelName",
            "tags": "Comma-separated model capabilities",
            "max_tokens": Integer (max token capacity),
            "model_type": "Type of model (chat, embedding, etc.)",
            "is_tools": Boolean (optional, indicates if model supports tools)
        },
        ...
    ]
}

Detailed Field Descriptions

• Factory Level Fields:

  • name (string): The official name of the LLM provider or factory.

  • logo (string): URL or file path to the factory's logo image. Often empty.

  • tags (string): A comma-separated list describing the capabilities or services the factory provides, e.g. "LLM,TEXT EMBEDDING,TTS".

  • status (string): Status indicator, where "1" typically means the factory is active or enabled.

  • llm (array): List of LLM model objects offered by this factory.

• LLM Model Level Fields:

  • llm_name (string): The unique name or identifier of the LLM model.

  • tags (string): Comma-separated tags describing the model's features, such as "LLM,CHAT,400k,IMAGE2TEXT".

  • max_tokens (integer, optional): The maximum token capacity supported by the model. Some entries may omit this field.

  • model_type (string): The broad category of the model, e.g., "chat", "embedding", "speech2text", "tts", "image2text", "rerank".

  • is_tools (boolean, optional): Indicates whether the model supports "tools" (e.g., external tool integration). Defaults to false if omitted.

Usage and Interaction

This file is primarily consumed by backend services or configuration loaders that require knowledge of available LLMs by different vendors for tasks such as:

• Discovery: Enumerate all LLM providers and their models.

• Filtering: Select models based on tags, token limits, or support for tools.

• Display: Show model details in user interfaces, including capabilities and constraints.

• Configuration: Automatically configure model clients or API calls based on metadata.

• Compatibility: Match application requirements with appropriate model types (e.g., embedding vs chat).

It may be loaded into memory as a JSON object and queried programmatically by:

• Client SDKs for choosing models.

• Admin dashboards for managing LLM integrations.

• Middleware that routes requests to the appropriate model endpoint.

Example Usage in Code (Python)

import json

# Load the JSON file
with open('llm_factories.json', 'r') as f:
    data = json.load(f)

# List all active factories
active_factories = [f for f in data['factory_llm_infos'] if f['status'] == '1']

# Find all chat models supporting tools from OpenAI
openai = next((f for f in active_factories if f['name'] == 'OpenAI'), None)
if openai:
    chat_models_with_tools = [
        m for m in openai['llm']
        if m['model_type'] == 'chat' and m.get('is_tools', False)
    ]
    for model in chat_models_with_tools:
        print(f"Model: {model['llm_name']}, Max Tokens: {model.get('max_tokens')}")

Important Implementation Details

• Extensibility: The JSON structure supports adding new factories or models without schema changes.

• Tags as Filters: The use of comma-separated tags strings allows flexible filtering by capabilities.

• Optional Fields: Some models may omit max_tokens or is_tools, requiring consumers to handle defaults.

• Model Types: The model_type field defines the primary usage of the model, guiding downstream usage logic.

• No Classes or Functions: This file is purely data; no classes, methods, or functions are defined here.

Interaction with Other System Components

• Model Loader/Registry: This file acts as a static registry for the system's LLM factory and model metadata.

• API Clients: May use model metadata from this file to select endpoints and configure requests.

• UI Components: Dashboards or configurators may parse and display factory/model information.

• Authentication/Authorization: May be coupled with credentials or access control mechanisms elsewhere.

• Routing/Middleware: Systems routing queries to different LLMs use this data to know available options.

Visual Diagram

Below is a flowchart representing the structure of the llm_factories.json file showing the hierarchical relationship between factories and their LLM models:

flowchart TD
    A[LLM Factories (factory_llm_infos)]
    A --> B1[Factory: OpenAI]
    A --> B2[Factory: xAI]
    A --> B3[Factory: TokenPony]
    A --> B4[Factory: Tongyi-Qianwen]
    A --> B5[Factory: ZHIPU-AI]
    A --> Bn[... Other Factories ...]

    subgraph Factory_Example [Factory "OpenAI"]
        B1 --> C1["gpt-5" Model]
        B1 --> C2["gpt-5-mini" Model]
        B1 --> C3["text-embedding-ada-002" Model]
        B1 --> C4["whisper-1" Model]
        B1 --> Cn["tts-1" Model]
    end

    subgraph Model_Details [LLM Model]
        style C1 fill:#e3f2fd,stroke:#0288d1,stroke-width:1px
        C1 --> M1[llm_name: string]
        C1 --> M2[tags: string]
        C1 --> M3[max_tokens: integer]
        C1 --> M4[model_type: string]
        C1 --> M5[is_tools: boolean (optional)]
    end

Summary

The llm_factories.json file is a centralized catalog enumerating LLM providers and their models with detailed metadata for each. It enables systems to dynamically discover, filter, and utilize a broad spectrum of AI models across multiple vendors, supporting diverse model types like chat, embedding, speech-to-text, and more. This data-driven approach facilitates scalable integration and selection of LLMs in complex AI ecosystems.

Because it is a static JSON file, it does not contain executable code but is essential for configuration and runtime decision-making in LLM-enabled applications.

End of Documentation