LangExtract

LangExtract uses a router system to match model_id requests to specific providers.

Resolution Methods

1. Auto-detection: If a model_id is provided that matches a registered pattern (e.g., mymodel-3b matching r'^mymodel'), the router automatically selects that provider.
2. Explicit Selection: Users can force a specific provider using its class name via lx.factory.ModelConfig:

   config = lx.factory.ModelConfig(provider="MyProviderLanguageModel")

   Partial matches on the class name (e.g., provider="myprovider") are also supported.
3. Default Provider: If a provider is instantiated without a model_id, it uses the provider's internal default.

Pattern Priority

All registered patterns have an equal priority of 0 by default. You can increase priority using the priority argument in @router.register to ensure specific patterns are matched before more general ones.

Providers can implement a custom schema by inheriting from langextract.core.schema.BaseSchema. This allows the provider to translate extraction requirements into specific API parameters (like JSON schemas).

The Schema Lifecycle:

1. from_examples(cls, examples_data, attribute_suffix): Analyze provided examples to build a schema dictionary.
2. to_provider_config(self): Convert the internal schema into a dictionary of keyword arguments (kwargs) for the provider.
3. requires_raw_output (property): Return True if the provider emits raw JSON/YAML without needing markdown fences.

Integrating the Schema into the Provider: In your BaseLanguageModel implementation, use get_schema_class() to link the schema, and ensure __init__ can receive schema configuration from kwargs when use_schema_constraints=True is used.

from langextract.core import schema as core_schema

class CustomProviderSchema(core_schema.BaseSchema):
    @classmethod
    def from_examples(cls, examples_data, attribute_suffix="_attributes"):
        # Analyze examples to find patterns
        # Build schema based on extraction classes and attributes seen
        return cls(schema_dict)

    def to_provider_config(self):
        # Convert schema to provider kwargs
        return {
            "response_schema": self._schema_dict,
            "enable_structured_output": True
        }

    @property
    def requires_raw_output(self):
        # True = provider emits raw JSON, no markdown fences needed
        return True

To use OpenAI models, install the optional dependency: pip install langextract[openai]. LangExtract automatically detects the provider based on the model_id (e.g., gpt-4o).

Batch API for large workloads

For non-latency-sensitive workloads, you can enable the OpenAI Batch API via language_model_params. This is opt-in and falls back to real-time calls if the prompt count is below the specified threshold.

Custom/OpenAI-compatible endpoints

If you are using an OpenAI-compatible endpoint or a non-GPT model ID that skips auto-routing, use ModelConfig to explicitly define the provider and its configuration.

import langextract as lx

# Standard OpenAI usage
result = lx.extract(
    text_or_documents=input_text,
    prompt_description=prompt,
    examples=examples,
    model_id="gpt-4o",
)

# Using OpenAI Batch API
result = lx.extract(
    text_or_documents=documents,
    prompt_description=prompt,
    examples=examples,
    model_id="gpt-4o-mini",
    language_model_params={
        "batch": {
            "enabled": True,
            "threshold": 50,
            "poll_interval": 10,
        }
    },
)

# Using custom OpenAI-compatible endpoints
from langextract.factory import ModelConfig

result = lx.extract(
    text_or_documents=input_text,
    prompt_description=prompt,
    examples=examples,
    config=ModelConfig(
        model_id="my-openai-compatible-model",
        provider="openai",
        provider_kwargs={"api_key": "sk-...", "base_url": "https://..."},
    ),
)

To contribute a new plugin to the LangExtract registry, follow these steps:

1. Prepare your PyPI package: Ensure the name starts with langextract- (e.g., langextract-provider-<name>) and is published.
2. Create a tracking issue: Open a tracking issue in the main LangExtract repository for integration and feedback.
3. Format the registry entry: Use the following template to add your row to COMMUNITY_PROVIDERS.md. Ensure entries are sorted alphabetically by Plugin Name and inserted above the marker line.

PR Checklist:

• PyPI package name starts with langextract- (recommended: langextract-provider-<name>)
• PyPI package is published (or will be soon) and listed in backticks
• Maintainer(s) listed as GitHub profile links (comma-separated if multiple)
• Repository link points to public GitHub repo
• Description clearly explains what your provider does
• Issue Link points to a tracking issue in the LangExtract repository
• Entries are sorted alphabetically by Plugin Name

| Your Plugin | `langextract-provider-yourname` | [@yourhandle](https://github.com/yourhandle) | [yourorg/yourrepo](https://github.com/yourorg/yourrepo) | Brief description (min 10 chars) | [#456](https://github.com/google/langextract/issues/456) |

The langextract-usage directory is an Agent Skill designed to teach AI coding assistants how to use LangExtract correctly. To use this skill, you must copy or symlink the directory into a path recognized by your Agent-Skills-compatible tool.

Installation Methods

Static Install (Copy): Use this if you want a standalone copy that does not change when the repository is updated.

cp -R skills/langextract-usage <tool-skill-path>

Dynamic Install (Symlink): Use this to track updates made to this repository.

ln -s "$(pwd)/skills/langextract-usage" <tool-skill-path>

Tool-Specific Paths

Depending on your tool, use the following canonical paths (examples provided for project-scope and user-scope):

Note for Copilot users: Copilot also accepts .claude/skills/ or .agents/skills/ at the project scope, and ~/.claude/skills/ or ~/.agents/skills/ at the user scope.

Note for Codex users: Codex scans .agents/skills/ from the current directory up through the repo root.

After activation, restart your agent session if the tool does not automatically detect the new skill.