feat: add MiniMax model support via OpenAI-compatible API

- Add MiniMax patterns (MiniMax-M2.5, etc.) to OpenAI provider
- Users can now use MiniMax with LangExtract by specifying:
  - model_id: 'MiniMax-M2.5' (or other MiniMax models)
  - provider_kwargs: { api_key, base_url: 'https://api.minimax.io/v1' }

Example:
    config = ModelConfig(
        model_id='MiniMax-M2.5',
        provider_kwargs={'api_key': '...', 'base_url': 'https://api.minimax.io/v1'}
    )
    model = create_model(config)

Author: Jithendra

langextract/providers/builtin_registry.py

@@ -48,4 +48,9 @@ class ProviderConfig(TypedDict):
         'target': 'langextract.providers.openai:OpenAILanguageModel',
         'priority': patterns.OPENAI_PRIORITY,
     },
+    {
+        'patterns': patterns.MINIMAX_PATTERNS,
+        'target': 'langextract.providers.minimax:MiniMaxLanguageModel',
+        'priority': patterns.MINIMAX_PRIORITY,
+    },
 ]

langextract/providers/minimax.py

@@ -0,0 +1,226 @@
+# Copyright 2025 Google LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MiniMax provider for LangExtract.
+
+This provider uses MiniMax's OpenAI-compatible API to extract structured
+information from text.
+
+Usage:
+    # Using factory
+    from langextract.factory import ModelConfig, create_model
+    
+    config = ModelConfig(
+        model_id="MiniMax-M2.5",
+        provider="MiniMaxLanguageModel",
+        provider_kwargs={
+            "api_key": "your-minimax-api-key"
+        }
+    )
+    model = create_model(config)
+    
+    result = lx.extract(
+        text_or_documents=text,
+        prompt_description=instructions,
+        model=model
+    )
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+from langextract.core import base_model
+from langextract.core import data
+from langextract.providers import patterns
+from langextract.providers import router
+
+
+_DEFAULT_MODEL_ID = "MiniMax-M2.5"
+_DEFAULT_BASE_URL = "https://api.minimax.io/v1"
+
+
+@router.register(
+    *patterns.MINIMAX_PATTERNS,
+    priority=patterns.MINIMAX_PRIORITY,
+)
+@dataclasses.dataclass(init=False)
+class MiniMaxLanguageModel(base_model.BaseLanguageModel):
+    """Language model inference using MiniMax's OpenAI-compatible API."""
+
+    model_id: str = _DEFAULT_MODEL_ID
+    api_key: str | None = None
+    base_url: str = _DEFAULT_BASE_URL
+    organization: str | None = None
+    format_type: data.FormatType = data.FormatType.JSON
+    temperature: float | None = None
+    max_workers: int = 10
+    _client: Any = dataclasses.field(default=None, repr=False, compare=False)
+    _extra_kwargs: dict[str, Any] = dataclasses.field(
+        default_factory=dict, repr=False, compare=False
+    )
+
+    @property
+    def requires_fence_output(self) -> bool:
+        """MiniMax returns raw JSON without fences."""
+        if self.format_type == data.FormatType.JSON:
+            return False
+        return super().requires_fence_output
+
+    def __post_init__(self):
+        """Initialize the OpenAI client with MiniMax configuration."""
+        try:
+            from openai import AsyncOpenAI
+        except ImportError as e:
+            raise ImportError(
+                "OpenAI package is required for MiniMax provider. "
+                "Install with: pip install langextract[openai]"
+            ) from e
+
+        if self._client is None:
+            self._client = AsyncOpenAI(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                organization=self.organization,
+                **self._extra_kwargs,
+            )
+
+    async def _generate(
+        self,
+        texts: list[str],
+        prompt_description: str,
+        extra_params: dict[str, Any] | None = None,
+    ) -> list[list[base_model.ExtractionCandidate]]:
+        """Generate extractions for the given texts."""
+        import asyncio
+
+        extra_params = extra_params or {}
+
+        async def process_single(text: str) -> list[base_model.ExtractionCandidate]:
+            response = await self._client.chat.completions.create(
+                model=self.model_id,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a helpful assistant that extracts structured information from text.",
+                    },
+                    {
+                        "role": "user",
+                        "content": f"{prompt_description}\n\nText: {text}",
+                    },
+                ],
+                response_format={"type": "json_object"}
+                if self.format_type == data.FormatType.JSON
+                else None,
+                temperature=self.temperature,
+                **extra_params,
+            )
+
+            content = response.choices[0].message.content
+            if not content:
+                return []
+
+            try:
+                import json
+
+                data = json.loads(content)
+                # Wrap in ExtractionCandidate format
+                if isinstance(data, list):
+                    return [
+                        base_model.ExtractionCandidate(
+                            extraction_text=item.get("text", str(item)),
+                            extraction_class=item.get("class", "unknown"),
+                            extraction_index=i,
+                        )
+                        for i, item in enumerate(data)
+                    ]
+                elif isinstance(data, dict):
+                    # For single object extractions
+                    return [
+                        base_model.ExtractionCandidate(
+                            extraction_text=str(v),
+                            extraction_class=k,
+                            extraction_index=i,
+                        )
+                        for i, (k, v) in enumerate(data.items())
+                    ]
+            except (json.JSONDecodeError, AttributeError):
+                pass
+
+            return [
+                base_model.ExtractionCandidate(
+                    extraction_text=content,
+                    extraction_class="extracted",
+                    extraction_index=0,
+                )
+            ]
+
+        # Process texts in parallel
+        tasks = [process_single(text) for text in texts]
+        results = await asyncio.gather(*tasks)
+        return results
+
+    def _generate_sync(
+        self,
+        texts: list[str],
+        prompt_description: str,
+        extra_params: dict[str, Any] | None = None,
+    ) -> list[list[base_model.ExtractionCandidate]]:
+        """Synchronous wrapper for generation."""
+        import asyncio
+
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If we're in an async context, we need to create a new loop
+                # This is a simplified sync wrapper - for production use async directly
+                import concurrent.futures
+
+                def run_in_executor():
+                    return asyncio.run(
+                        self._generate(texts, prompt_description, extra_params)
+                    )
+
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(run_in_executor)
+                    return future.result()
+        except RuntimeError:
+            # No event loop, run directly
+            return asyncio.run(
+                self._generate(texts, prompt_description, extra_params)
+            )
+
+    def __call__(
+        self,
+        texts: Sequence[str],
+        prompt_description: str,
+        extra_params: dict[str, Any] | None = None,
+    ) -> list[list[base_model.ExtractionCandidate]]:
+        """Synchronous interface for the model."""
+        return self._generate_sync(list(texts), prompt_description, extra_params)
+
+    async def _call_async(
+        self,
+        texts: Sequence[str],
+        prompt_description: str,
+        extra_params: dict[str, Any] | None = None,
+    ) -> list[list[base_model.ExtractionCandidate]]:
+        """Asynchronous interface for the model."""
+        return await self._generate(list(texts), prompt_description, extra_params)
+
+    def close(self):
+        """Close the client connection."""
+        # AsyncOpenAI doesn't need explicit close
+        pass

langextract/providers/patterns.py

@@ -22,12 +22,15 @@
 GEMINI_PATTERNS = (r'^gemini',)
 GEMINI_PRIORITY = 10
 
-# OpenAI provider patterns
+# OpenAI provider patterns (includes MiniMax via OpenAI-compatible API)
 OPENAI_PATTERNS = (
     r'^gpt-4',
     r'^gpt4\.',
     r'^gpt-5',
     r'^gpt5\.',
+    # MiniMax models (OpenAI-compatible API)
+    r'^MiniMax',
+    r'^minimax',
 )
 OPENAI_PRIORITY = 10
 
@@ -62,3 +65,10 @@
     r'^WizardLM/',
 )
 OLLAMA_PRIORITY = 10
+
+# MiniMax provider patterns (OpenAI-compatible API)
+MINIMAX_PATTERNS = (
+    r'^MiniMax',
+    r'^minimax',
+)
+MINIMAX_PRIORITY = 10

test_minimax.py

@@ -0,0 +1,46 @@
+"""Test LangExtract with MiniMax using OpenAI-compatible API."""
+import os
+import langextract as lx
+
+# Get MiniMax API key from environment
+MINIMAX_API_KEY = os.getenv("MINIMAX_API_KEY", "")
+
+if not MINIMAX_API_KEY:
+    print("ERROR: MINIMAX_API_KEY not set!")
+    exit(1)
+
+# Sample text to extract from
+sample_text = """
+Patient John Doe, age 45, was admitted to the hospital on March 15, 2026.
+He presented with symptoms of fever, cough, and shortness of breath.
+Medical history includes hypertension and diabetes type 2.
+Current medications: Metformin 500mg twice daily, Lisinopril 10mg once daily.
+"""
+
+# Define extraction instructions
+instructions = "Extract patient information including name, age, symptoms, medical history, and medications."
+
+# Try using MiniMax via OpenAI-compatible API
+try:
+    print("Testing LangExtract with MiniMax (via OpenAI-compatible API)...")
+    print(f"API Key: {MINIMAX_API_KEY[:10]}...")
+    print()
+    
+    result = lx.extract(
+        text_or_documents=sample_text,
+        prompt_description=instructions,
+        model_id="MiniMax-M2.5",  # This won't auto-detect, need to specify provider
+        provider="OpenAILanguageModel",
+        provider_kwargs={
+            "api_key": MINIMAX_API_KEY,
+            "base_url": "https://api.minimax.io/v1"
+        }
+    )
+    
+    print("SUCCESS! Extraction result:")
+    print(result)
+    
+except Exception as e:
+    print(f"ERROR: {type(e).__name__}: {e}")
+    print()
+    print("Let's try a different approach...")

test_minimax2.py

@@ -0,0 +1,56 @@
+"""Test LangExtract with MiniMax using OpenAI-compatible API - Factory approach."""
+import os
+import langextract as lx
+from langextract import factory
+
+# Get MiniMax API key from environment
+MINIMAX_API_KEY = os.getenv("MINIMAX_API_KEY", "")
+
+if not MINIMAX_API_KEY:
+    print("ERROR: MINIMAX_API_KEY not set!")
+    exit(1)
+
+# Sample text to extract from
+sample_text = """
+Patient John Doe, age 45, was admitted to the hospital on March 15, 2026.
+He presented with symptoms of fever, cough, and shortness of breath.
+Medical history includes hypertension and diabetes type 2.
+Current medications: Metformin 500mg twice daily, Lisinopril 10mg once daily.
+"""
+
+# Define extraction instructions
+instructions = "Extract patient information including name, age, symptoms, medical history, and medications."
+
+# Try using MiniMax via OpenAI-compatible API using factory
+try:
+    print("Testing LangExtract with MiniMax (via OpenAI-compatible API)...")
+    print(f"API Key: {MINIMAX_API_KEY[:10]}...")
+    print()
+    
+    # Use factory to create model with custom provider
+    config = factory.ModelConfig(
+        model_id="MiniMax-M2.5",
+        provider="OpenAILanguageModel",
+        provider_kwargs={
+            "api_key": MINIMAX_API_KEY,
+            "base_url": "https://api.minimax.io/v1"
+        }
+    )
+    model = factory.create_model(config)
+    
+    # Now use the model
+    extract = lx.LangExtract(model=model)
+    result = extract.extract(
+        text_or_documents=sample_text,
+        prompt_description=instructions,
+    )
+    
+    print("SUCCESS! Extraction result:")
+    print(result)
+    
+except Exception as e:
+    import traceback
+    print(f"ERROR: {type(e).__name__}: {e}")
+    traceback.print_exc()
+    print()
+    print("Trying alternative approach...")