fix: update MiniMax model metadata and endpoints (#1103)

* fix: update MiniMax model metadata and endpoints

Keep context limits, tiered costs, and regional endpoint configuration aligned with current provider documentation.

* Remove documentation file per review

---------

Co-authored-by: octo-patch <266937838+octo-patch@users.noreply.github.com>

Author: octo-patch

README.md

@@ -155,7 +155,7 @@ There are other pipelines that can be used to extract information from multiple
 
 For each of these graphs there is the multi version. It allows to make calls of the LLM in parallel.
 
-It is possible to use different LLM through APIs, such as **OpenAI**, **Groq**, **Azure**, **Gemini**, **MiniMax** and more, or local models using **Ollama**.
+It is possible to use different LLM through APIs, such as **OpenAI**, **Groq**, **Azure**, **Gemini**, **[MiniMax](docs/minimax.md)** and more, or local models using **Ollama**.
 
 Remember to have [Ollama](https://ollama.com/) installed and download the models using the **ollama pull** command, if you want to use local models.
 

scrapegraphai/helpers/models_tokens.py

@@ -412,8 +412,8 @@
         "grok-beta": 128000,
     },
     "minimax": {
-        "MiniMax-M3": 524288,
-        "MiniMax-M2.7": 204000,
-        "MiniMax-M2.7-highspeed": 204000,
+        "MiniMax-M3": 1000000,
+        "MiniMax-M2.7": 204800,
+        "MiniMax-M2.7-highspeed": 204800,
     },
 }

scrapegraphai/models/minimax.py

@@ -5,6 +5,9 @@
 from langchain_openai import ChatOpenAI
 
 
+DEFAULT_MINIMAX_OPENAI_BASE_URL = "https://api.minimax.io/v1"
+
+
 class MiniMax(ChatOpenAI):
     """
     A wrapper for the ChatOpenAI class (MiniMax uses an OpenAI-compatible API) that
@@ -18,6 +21,7 @@ class MiniMax(ChatOpenAI):
     def __init__(self, **llm_config):
         if "api_key" in llm_config:
             llm_config["openai_api_key"] = llm_config.pop("api_key")
-        llm_config["openai_api_base"] = "https://api.minimax.io/v1"
+        if "base_url" not in llm_config and "openai_api_base" not in llm_config:
+            llm_config["openai_api_base"] = DEFAULT_MINIMAX_OPENAI_BASE_URL
 
         super().__init__(**llm_config)

scrapegraphai/utils/custom_callback.py

@@ -15,11 +15,19 @@
 from langchain_core.outputs import ChatGeneration, LLMResult
 from langchain_core.tracers.context import register_configure_hook
 
-from .model_costs import MODEL_COST_PER_1K_TOKENS_INPUT, MODEL_COST_PER_1K_TOKENS_OUTPUT
+from .model_costs import (
+    MODEL_COST_PER_1K_TOKENS_INPUT,
+    MODEL_COST_TIERS_PER_1K_TOKENS,
+    get_model_cost_per_1k_tokens,
+)
 
 
 def get_token_cost_for_model(
-    model_name: str, num_tokens: int, is_completion: bool = False
+    model_name: str,
+    num_tokens: int,
+    is_completion: bool = False,
+    input_tokens: Optional[int] = None,
+    service_tier: str = "standard",
 ) -> float:
     """
     Get the cost in USD for a given model and number of tokens.
@@ -29,15 +37,30 @@ def get_token_cost_for_model(
         num_tokens: Number of tokens.
         is_completion: Whether the model is used for completion or not.
             Defaults to False.
+        input_tokens: Number of input tokens used to select a pricing tier.
+        service_tier: Provider service tier. Defaults to standard.
 
     Returns:
         Cost in USD.
     """
-    if model_name not in MODEL_COST_PER_1K_TOKENS_INPUT:
+    if (
+        model_name not in MODEL_COST_PER_1K_TOKENS_INPUT
+        and model_name not in MODEL_COST_TIERS_PER_1K_TOKENS
+    ):
         return 0.0
-    if is_completion:
-        return MODEL_COST_PER_1K_TOKENS_OUTPUT[model_name] * (num_tokens / 1000)
-    return MODEL_COST_PER_1K_TOKENS_INPUT[model_name] * (num_tokens / 1000)
+    if input_tokens is None:
+        if is_completion and model_name in MODEL_COST_TIERS_PER_1K_TOKENS:
+            raise ValueError(
+                "input_tokens is required for completion costs with tiered pricing"
+            )
+        input_tokens = num_tokens
+    rate = get_model_cost_per_1k_tokens(
+        model_name,
+        input_tokens,
+        is_completion=is_completion,
+        service_tier=service_tier,
+    )
+    return rate * (num_tokens / 1000)
 
 
 class CustomCallbackHandler(BaseCallbackHandler):
@@ -49,10 +72,11 @@ class CustomCallbackHandler(BaseCallbackHandler):
     successful_requests: int = 0
     total_cost: float = 0.0
 
-    def __init__(self, llm_model_name: str) -> None:
+    def __init__(self, llm_model_name: str, service_tier: str = "standard") -> None:
         super().__init__()
         self._lock = threading.Lock()
         self.model_name = llm_model_name if llm_model_name else "unknown"
+        self.service_tier = service_tier
 
     def __repr__(self) -> str:
         return (
@@ -114,11 +138,23 @@ def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
             token_usage = response.llm_output["token_usage"]
             completion_tokens = token_usage.get("completion_tokens", 0)
             prompt_tokens = token_usage.get("prompt_tokens", 0)
-        if self.model_name in MODEL_COST_PER_1K_TOKENS_INPUT:
+        if (
+            self.model_name in MODEL_COST_PER_1K_TOKENS_INPUT
+            or self.model_name in MODEL_COST_TIERS_PER_1K_TOKENS
+        ):
             completion_cost = get_token_cost_for_model(
-                self.model_name, completion_tokens, is_completion=True
+                self.model_name,
+                completion_tokens,
+                is_completion=True,
+                input_tokens=prompt_tokens,
+                service_tier=self.service_tier,
+            )
+            prompt_cost = get_token_cost_for_model(
+                self.model_name,
+                prompt_tokens,
+                input_tokens=prompt_tokens,
+                service_tier=self.service_tier,
             )
-            prompt_cost = get_token_cost_for_model(self.model_name, prompt_tokens)
         else:
             completion_cost = 0
             prompt_cost = 0
@@ -147,11 +183,11 @@ def __deepcopy__(self, memo: Any) -> "CustomCallbackHandler":
 
 
 @contextmanager
-def get_custom_callback(llm_model_name: str):
+def get_custom_callback(llm_model_name: str, service_tier: str = "standard"):
     """
     Function to get custom callback for LLM token usage statistics.
     """
-    cb = CustomCallbackHandler(llm_model_name)
+    cb = CustomCallbackHandler(llm_model_name, service_tier=service_tier)
     custom_callback.set(cb)
     yield cb
     custom_callback.set(None)

scrapegraphai/utils/llm_callback_manager.py

@@ -47,7 +47,15 @@ def exclusive_get_callback(self, llm_model, llm_model_name):
         """
         if CustomLLMCallbackManager._lock.acquire(blocking=False):
             try:
-                if isinstance(llm_model, ChatOpenAI) or isinstance(
+                from ..models.minimax import MiniMax
+
+                if isinstance(llm_model, MiniMax):
+                    service_tier = llm_model.service_tier or "standard"
+                    with get_custom_callback(
+                        llm_model_name, service_tier=service_tier
+                    ) as cb:
+                        yield cb
+                elif isinstance(llm_model, ChatOpenAI) or isinstance(
                     llm_model, AzureChatOpenAI
                 ):
                     with get_openai_callback() as cb:

scrapegraphai/utils/model_costs.py

@@ -50,6 +50,7 @@
     "amazon.titan-text-express-v1": 0.0002,
     "amazon.titan-text-lite-v1": 0.00015,
     "amazon.titan-text-premier-v1:0": 0.0005,
+    "MiniMax-M2.7": 0.0003,
 }
 
 """
@@ -102,4 +103,84 @@
     "amazon.titan-text-express-v1": 0.0006,
     "amazon.titan-text-lite-v1": 0.0002,
     "amazon.titan-text-premier-v1:0": 0.0015,
+    "MiniMax-M2.7": 0.0012,
 }
+
+
+MODEL_CACHE_COST_PER_1K_TOKENS = {
+    "MiniMax-M2.7": {"read": 0.00006, "write": 0.000375},
+}
+
+
+MODEL_COST_TIERS_PER_1K_TOKENS = {
+    "MiniMax-M3": {
+        "standard": (
+            {
+                "input_tokens_lte": 512000,
+                "input": 0.0003,
+                "output": 0.0012,
+                "cache_read": 0.00006,
+                "cache_write": None,
+            },
+            {
+                "input_tokens_gt": 512000,
+                "input": 0.0006,
+                "output": 0.0024,
+                "cache_read": 0.00012,
+                "cache_write": None,
+            },
+        ),
+        "priority": (
+            {
+                "input_tokens_lte": 512000,
+                "input": 0.00045,
+                "output": 0.0018,
+                "cache_read": 0.00009,
+                "cache_write": None,
+            },
+            {
+                "input_tokens_gt": 512000,
+                "input": 0.0009,
+                "output": 0.0036,
+                "cache_read": 0.00018,
+                "cache_write": None,
+            },
+        ),
+    }
+}
+
+
+def get_model_cost_per_1k_tokens(
+    model_name: str,
+    input_tokens: int,
+    is_completion: bool = False,
+    service_tier: str = "standard",
+) -> float:
+    """Return the applicable input or output rate for a model."""
+    if input_tokens < 0:
+        raise ValueError("input_tokens must not be negative")
+
+    if model_name in MODEL_COST_TIERS_PER_1K_TOKENS:
+        try:
+            pricing_tiers = MODEL_COST_TIERS_PER_1K_TOKENS[model_name][service_tier]
+        except KeyError as exc:
+            raise ValueError(
+                f"Unsupported service tier {service_tier!r} for {model_name}"
+            ) from exc
+
+        rate_key = "output" if is_completion else "input"
+        for pricing in pricing_tiers:
+            upper_bound = pricing.get("input_tokens_lte")
+            lower_bound = pricing.get("input_tokens_gt")
+            if upper_bound is not None and input_tokens <= upper_bound:
+                return float(pricing[rate_key])
+            if lower_bound is not None and input_tokens > lower_bound:
+                return float(pricing[rate_key])
+        raise ValueError(f"No pricing tier matches {input_tokens} input tokens")
+
+    costs = (
+        MODEL_COST_PER_1K_TOKENS_OUTPUT
+        if is_completion
+        else MODEL_COST_PER_1K_TOKENS_INPUT
+    )
+    return costs[model_name]