@stephen-lord/docs 1.0.0 → 1.0.1

package/dist-docs/Agent-Skills-for-Context-Engineering/examples/interleaved_thinking/docs/m2-1.md

@@ -0,0 +1,224 @@
+# Compatible Anthropic API
+
+> Call MiniMax models using the Anthropic SDK
+
+To meet developers' needs for the Anthropic API ecosystem, our API now supports the Anthropic API format. With simple configuration, you can integrate MiniMax capabilities into the Anthropic API ecosystem.
+
+## Quick Start
+
+### 1. Install Anthropic SDK
+
+<CodeGroup>
+  ```bash Python theme={null}
+  pip install anthropic
+  ```
+
+  ```bash Node.js theme={null}
+  npm install @anthropic-ai/sdk
+  ```
+</CodeGroup>
+
+### 2. Configure Environment Variables
+
+For international users, use `https://api.minimax.io/anthropic`; for users in China, use `https://api.minimaxi.com/anthropic`
+
+```bash  theme={null}
+export ANTHROPIC_BASE_URL=https://api.minimax.io/anthropic
+export ANTHROPIC_API_KEY=${YOUR_API_KEY}
+```
+
+### 3. Call API
+
+```python Python theme={null}
+import anthropic
+
+client = anthropic.Anthropic()
+
+message = client.messages.create(
+    model="MiniMax-M2.1",
+    max_tokens=1000,
+    system="You are a helpful assistant.",
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Hi, how are you?"
+                }
+            ]
+        }
+    ]
+)
+
+for block in message.content:
+    if block.type == "thinking":
+        print(f"Thinking:\n{block.thinking}\n")
+    elif block.type == "text":
+        print(f"Text:\n{block.text}\n")
+```
+
+### 4. Important Note
+
+In multi-turn function call conversations, the complete model response (i.e., the assistant message) must be append to the conversation history to maintain the continuity of the reasoning chain.
+
+* Append the full `response.content` list to the message history (includes all content blocks: thinking/text/tool\_use)
+
+## Supported Models
+
+When using the Anthropic SDK, the `MiniMax-M2.1` `MiniMax-M2.1-lightning` `MiniMax-M2` model is supported:
+
+| Model Name             | Description                                                                                                                               |
+| :--------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- |
+| MiniMax-M2.1           | Powerful Multi-Language Programming Capabilities with Comprehensively Enhanced Programming Experience (output speed approximately 60 tps) |
+| MiniMax-M2.1-lightning | Faster and More Agile (output speed approximately 100 tps)                                                                                |
+| MiniMax-M2             | Agentic capabilities, Advanced reasoning                                                                                                  |
+
+<Note>
+  The Anthropic API compatibility interface currently only supports the
+  `MiniMax-M2.1` `MiniMax-M2.1-lightning` `MiniMax-M2` model. For other models, please use the standard MiniMax API
+  interface.
+</Note>
+
+## Compatibility
+
+### Supported Parameters
+
+When using the Anthropic SDK, we support the following input parameters:
+
+| Parameter            | Support Status  | Description                                                         |
+| :------------------- | :-------------- | :------------------------------------------------------------------ |
+| `model`              | Fully supported | supports `MiniMax-M2.1` `MiniMax-M2.1-lightning` `MiniMax-M2` model |
+| `messages`           | Partial support | Supports text and tool calls, no image/document input               |
+| `max_tokens`         | Fully supported | Maximum number of tokens to generate                                |
+| `stream`             | Fully supported | Streaming response                                                  |
+| `system`             | Fully supported | System prompt                                                       |
+| `temperature`        | Fully supported | Range (0.0, 1.0], controls output randomness, recommended value: 1  |
+| `tool_choice`        | Fully supported | Tool selection strategy                                             |
+| `tools`              | Fully supported | Tool definitions                                                    |
+| `top_p`              | Fully supported | Nucleus sampling parameter                                          |
+| `metadata`           | Fully Supported | Metadata                                                            |
+| `thinking`           | Fully Supported | Reasoning Content                                                   |
+| `top_k`              | Ignored         | This parameter will be ignored                                      |
+| `stop_sequences`     | Ignored         | This parameter will be ignored                                      |
+| `service_tier`       | Ignored         | This parameter will be ignored                                      |
+| `mcp_servers`        | Ignored         | This parameter will be ignored                                      |
+| `context_management` | Ignored         | This parameter will be ignored                                      |
+| `container`          | Ignored         | This parameter will be ignored                                      |
+
+### Messages Field Support
+
+| Field Type           | Support Status  | Description                      |
+| :------------------- | :-------------- | :------------------------------- |
+| `type="text"`        | Fully supported | Text messages                    |
+| `type="tool_use"`    | Fully supported | Tool calls                       |
+| `type="tool_result"` | Fully supported | Tool call results                |
+| `type="thinking"`    | Fully supported | Reasoning Content                |
+| `type="image"`       | Not supported   | Image input not supported yet    |
+| `type="document"`    | Not supported   | Document input not supported yet |
+
+## Examples
+
+### Streaming Response
+
+```python Python theme={null}
+import anthropic
+
+client = anthropic.Anthropic()
+
+print("Starting stream response...\n")
+print("=" * 60)
+print("Thinking Process:")
+print("=" * 60)
+
+stream = client.messages.create(
+    model="MiniMax-M2.1",
+    max_tokens=1000,
+    system="You are a helpful assistant.",
+    messages=[
+        {"role": "user", "content": [{"type": "text", "text": "Hi, how are you?"}]}
+    ],
+    stream=True,
+)
+
+reasoning_buffer = ""
+text_buffer = ""
+
+for chunk in stream:
+    if chunk.type == "content_block_start":
+        if hasattr(chunk, "content_block") and chunk.content_block:
+            if chunk.content_block.type == "text":
+                print("\n" + "=" * 60)
+                print("Response Content:")
+                print("=" * 60)
+
+    elif chunk.type == "content_block_delta":
+        if hasattr(chunk, "delta") and chunk.delta:
+            if chunk.delta.type == "thinking_delta":
+                # Stream output thinking process
+                new_thinking = chunk.delta.thinking
+                if new_thinking:
+                    print(new_thinking, end="", flush=True)
+                    reasoning_buffer += new_thinking
+            elif chunk.delta.type == "text_delta":
+                # Stream output text content
+                new_text = chunk.delta.text
+                if new_text:
+                    print(new_text, end="", flush=True)
+                    text_buffer += new_text
+
+print("\n")
+```
+
+### Tool Use & Interleaved Thinking
+
+Learn how to use M2.1 Tool Use and Interleaved Thinking capabilities with Anthropic SDK, please refer to the following documentation.
+
+<Columns cols={1}>
+  <Card title="M2.1 Tool Use & Interleaved Thinking" icon="book-open" href="/guides/text-m2-function-call#anthropic-sdk" arrow="true" cta="Click here">
+    Learn how to leverage MiniMax-M2.1 tool calling and interleaved thinking capabilities to enhance performance in complex tasks.
+  </Card>
+</Columns>
+
+## Important Notes
+
+<Warning>
+  1. The Anthropic API compatibility interface currently only supports the `MiniMax-M2.1` `MiniMax-M2` model
+
+  2. The `temperature` parameter range is (0.0, 1.0], values outside this range will return an error
+
+  3. Some Anthropic parameters (such as `thinking`, `top_k`, `stop_sequences`, `service_tier`, `mcp_servers`, `context_management`, `container`) will be ignored
+
+  4. Image and document type inputs are not currently supported
+</Warning>
+
+## Related Links
+
+* [Anthropic SDK Documentation](https://docs.anthropic.com/en/api/client-sdks)
+* [MiniMax Text Generation API](/api-reference/text-intro)
+* [M2.1 Tool Use & Interleaved Thinking](/guides/text-m2-function-call)
+
+## Recommended Reading
+
+<Columns cols={2}>
+  <Card title="Text Generation" icon="book-open" href="/guides/text-generation" arrow="true" cta="Click here">
+    Supports text generation via compatible Anthropic API and OpenAI API.
+  </Card>
+
+  <Card title="Compatible OpenAI API" icon="book-open" href="/api-reference/text-openai-api" arrow="true" cta="Click here">
+    Use OpenAI SDK with MiniMax models
+  </Card>
+
+  <Card title="M2.1 for AI Coding Tools" icon="book-open" href="/guides/text-ai-coding-tools" arrow="true" cta="Click here">
+    MiniMax-M2.1 excels at code understanding, dialogue, and reasoning.
+  </Card>
+
+  <Card title="M2.1 Tool Use & Interleaved Thinking" icon="book-open" href="/guides/text-m2-function-call" arrow="true" cta="Click here">
+    AI models can call external functions to extend their capabilities.
+  </Card>
+</Columns>
+
+
+---
+
+> To find navigation and other pages in this documentation, fetch the llms.txt file at: https://platform.minimax.io/docs/llms.txt

package/dist-docs/Agent-Skills-for-Context-Engineering/examples/interleaved_thinking/examples/01_basic_capture.py

@@ -0,0 +1,76 @@
+"""
+Example 1: Basic Trace Capture
+
+Demonstrates capturing reasoning traces from M2.1 for a simple task.
+This shows how interleaved thinking provides visibility into agent decisions.
+"""
+
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+from reasoning_trace_optimizer import TraceCapture
+from reasoning_trace_optimizer.capture import format_trace_for_display
+
+# Load environment variables from the project root
+env_path = Path(__file__).parent.parent / ".env"
+load_dotenv(env_path)
+
+
+def main():
+    """Run a simple task and capture the reasoning trace."""
+
+    # Initialize capture with M2.1
+    capture = TraceCapture(
+        api_key=os.getenv("ANTHROPIC_API_KEY"),
+        base_url="https://api.minimax.io/anthropic",
+        model="MiniMax-M2.1",
+    )
+
+    # Define a simple task
+    task = "Explain what interleaved thinking is and why it matters for AI agents."
+    system_prompt = "You are an AI researcher explaining concepts clearly."
+
+    print("=" * 60)
+    print("BASIC TRACE CAPTURE EXAMPLE")
+    print("=" * 60)
+    print(f"\nTask: {task}")
+    print(f"System Prompt: {system_prompt}")
+    print("\nCapturing reasoning trace...\n")
+
+    # Capture the trace
+    trace = capture.run(
+        task=task,
+        system_prompt=system_prompt,
+        max_turns=5,
+    )
+
+    # Display the trace
+    print(format_trace_for_display(trace))
+
+    # Summary statistics
+    print("\n" + "=" * 60)
+    print("TRACE STATISTICS")
+    print("=" * 60)
+    print(f"Session ID: {trace.session_id}")
+    print(f"Model: {trace.model}")
+    print(f"Success: {trace.success}")
+    print(f"Total Turns: {trace.total_turns}")
+    print(f"Thinking Blocks: {len(trace.thinking_blocks)}")
+    print(f"Tool Calls: {len(trace.tool_calls)}")
+    print(f"Total Tokens: {trace.total_tokens}")
+
+    # Show each thinking block summary
+    if trace.thinking_blocks:
+        print("\n" + "=" * 60)
+        print("THINKING BLOCK SUMMARIES")
+        print("=" * 60)
+        for i, thinking in enumerate(trace.thinking_blocks):
+            print(f"\n[Turn {thinking.turn_index}] ({len(thinking.content)} chars)")
+            # Show first 200 chars
+            preview = thinking.content[:200].replace("\n", " ")
+            print(f"  Preview: {preview}...")
+
+
+if __name__ == "__main__":
+    main()

package/dist-docs/Agent-Skills-for-Context-Engineering/examples/interleaved_thinking/examples/02_tool_usage.py

@@ -0,0 +1,187 @@
+"""
+Example 2: Tool Usage with Trace Capture
+
+Demonstrates how M2.1's interleaved thinking reasons between tool calls.
+This is where interleaved thinking really shines - you can see the model
+adapting to tool outputs in real-time.
+"""
+
+import json
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+from reasoning_trace_optimizer import TraceCapture
+from reasoning_trace_optimizer.capture import format_trace_for_display
+
+# Load environment variables from the project root
+env_path = Path(__file__).parent.parent / ".env"
+load_dotenv(env_path)
+
+
+# Define mock tools
+TOOLS = [
+    {
+        "name": "get_weather",
+        "description": "Get current weather for a location. Returns temperature and conditions.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "City name, e.g., 'San Francisco, CA'",
+                }
+            },
+            "required": ["location"],
+        },
+    },
+    {
+        "name": "get_forecast",
+        "description": "Get 3-day weather forecast for a location.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "City name",
+                },
+                "days": {
+                    "type": "integer",
+                    "description": "Number of days (1-3)",
+                    "default": 3,
+                },
+            },
+            "required": ["location"],
+        },
+    },
+]
+
+
+# Mock tool executor
+def execute_tool(name: str, input_data: dict) -> str:
+    """Execute a mock tool and return results."""
+    if name == "get_weather":
+        location = input_data.get("location", "Unknown")
+        # Simulate different weather for different cities
+        if "san francisco" in location.lower():
+            return json.dumps({
+                "location": location,
+                "temperature": "18°C",
+                "conditions": "Foggy",
+                "humidity": "85%",
+            })
+        elif "new york" in location.lower():
+            return json.dumps({
+                "location": location,
+                "temperature": "22°C",
+                "conditions": "Partly cloudy",
+                "humidity": "60%",
+            })
+        else:
+            return json.dumps({
+                "location": location,
+                "temperature": "20°C",
+                "conditions": "Clear",
+                "humidity": "50%",
+            })
+
+    elif name == "get_forecast":
+        location = input_data.get("location", "Unknown")
+        days = input_data.get("days", 3)
+        forecast = []
+        for i in range(days):
+            forecast.append({
+                "day": i + 1,
+                "high": f"{20 + i * 2}°C",
+                "low": f"{12 + i}°C",
+                "conditions": ["Sunny", "Cloudy", "Rainy"][i % 3],
+            })
+        return json.dumps({
+            "location": location,
+            "forecast": forecast,
+        })
+
+    return json.dumps({"error": f"Unknown tool: {name}"})
+
+
+def main():
+    """Run a task with tools and observe interleaved thinking."""
+
+    capture = TraceCapture(
+        api_key=os.getenv("ANTHROPIC_API_KEY"),
+        base_url="https://api.minimax.io/anthropic",
+        model="MiniMax-M2.1",
+    )
+
+    task = """Compare the current weather in San Francisco and New York City.
+    Then tell me which city would be better for outdoor activities this weekend."""
+
+    system_prompt = """You are a helpful weather assistant.
+    Use the available tools to get accurate weather information.
+    Always provide specific data to support your recommendations."""
+
+    print("=" * 60)
+    print("TOOL USAGE WITH INTERLEAVED THINKING")
+    print("=" * 60)
+    print(f"\nTask: {task}")
+    print(f"\nTools available: {', '.join(t['name'] for t in TOOLS)}")
+    print("\nCapturing trace with tool usage...\n")
+
+    # Capture the trace (using non-streaming for reliability)
+    trace = capture.run(
+        task=task,
+        system_prompt=system_prompt,
+        tools=TOOLS,
+        tool_executor=execute_tool,
+        max_turns=10,
+    )
+
+    print("\n\n" + "=" * 60)
+    print("TRACE ANALYSIS")
+    print("=" * 60)
+
+    print(f"\nSuccess: {trace.success}")
+    print(f"Total Turns: {trace.total_turns}")
+    print(f"Thinking Blocks: {len(trace.thinking_blocks)}")
+    print(f"Tool Calls: {len(trace.tool_calls)}")
+
+    # Show how thinking evolved between tool calls
+    print("\n" + "=" * 60)
+    print("THINKING EVOLUTION ACROSS TOOL CALLS")
+    print("=" * 60)
+
+    for i, thinking in enumerate(trace.thinking_blocks):
+        print(f"\n[Turn {thinking.turn_index}] Thinking Block {i + 1}")
+        print("-" * 40)
+
+        # Show what tool was called after this thinking
+        turn_tools = trace.get_tool_calls_at_turn(thinking.turn_index)
+        if turn_tools:
+            print(f"Following action: Called {', '.join(t.name for t in turn_tools)}")
+        else:
+            print("Following action: Generated response")
+
+        # Show key reasoning points (first 300 chars)
+        print(f"\nReasoning preview:\n{thinking.content[:300]}...")
+
+    # Show tool call results
+    print("\n" + "=" * 60)
+    print("TOOL CALL SUMMARY")
+    print("=" * 60)
+
+    for tc in trace.tool_calls:
+        status = "✅" if tc.success else "❌"
+        print(f"\n{status} {tc.name}")
+        print(f"   Input: {json.dumps(tc.input)}")
+        print(f"   Result: {tc.result[:100]}..." if tc.result and len(tc.result) > 100 else f"   Result: {tc.result}")
+
+    # Final response
+    if trace.final_response:
+        print("\n" + "=" * 60)
+        print("FINAL RESPONSE")
+        print("=" * 60)
+        print(trace.final_response)
+
+
+if __name__ == "__main__":
+    main()