MiniMax Releases M2.1: An Enhanced M2 Model with Options like Multi-Coding Language Assist, API Integration, and Improved Instruments for Structured Coding

import os
from getpass import getpass
os.environ['ANTHROPIC_BASE_URL'] = 'https://api.minimax.io/anthropic'
os.environ['ANTHROPIC_API_KEY'] = getpass('Enter MiniMax API Key: ')

import anthropic

shopper = anthropic.Anthropic()

message = shopper.messages.create(
    mannequin="MiniMax-M2.1",
    max_tokens=1000,
    system="You're a useful assistant.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Hi, how are you?"
                }
            ]
        }
    ]
)

for block in message.content material:
    if block.kind == "pondering":
        print(f"Considering:n{block.pondering}n")
    elif block.kind == "textual content":
        print(f"Textual content:n{block.textual content}n")

Considering:
The person is simply asking how I'm doing. This can be a pleasant greeting, so I ought to reply in a heat, conversational approach. I am going to preserve it easy and pleasant.

Textual content:
Hello! I am doing nicely, thanks for asking! 😊

I am prepared that will help you with no matter you want as we speak. Whether or not it is coding, answering questions, brainstorming concepts, or simply chatting, I am right here for you.

What can I make it easier to with?

import anthropic

shopper = anthropic.Anthropic()

def run_test(immediate: str, title: str):
    print(f"n{'='*80}")
    print(f"TEST: {title}")
    print(f"{'='*80}n")

    message = shopper.messages.create(
        mannequin="MiniMax-M2.1",
        max_tokens=10000,
        system=(
            "You're a senior software program engineer. "
            "Write production-quality code with clear construction, "
            "specific assumptions, and minimal however enough reasoning. "
            "Keep away from pointless verbosity."
        ),
        messages=[
            {
                "role": "user",
                "content": [{"type": "text", "text": prompt}]
            }
        ]
    )

    for block in message.content material:
        if block.kind == "pondering":
            print("🧠 Considering:n", block.pondering, "n")
        elif block.kind == "textual content":
            print("📄 Output:n", block.textual content, "n")

PROMPT= """
Design a small Python service that processes person occasions.

Necessities:
1. Occasions arrive as dictionaries with keys: user_id, event_type, timestamp.
2. Validate enter strictly (sorts + required keys).
3. Mixture occasions per person in reminiscence.
4. Expose two capabilities:
   - ingest_event(occasion: dict) -> None
   - get_user_summary(user_id: str) -> dict
5. Code have to be:
   - Testable
   - Thread-safe
   - Simply extensible for brand spanking new occasion sorts
6. Do NOT use exterior libraries.

Present:
- Code solely
- Temporary inline feedback the place wanted
"""

run_test(immediate=PROMPT, title="Instruction Following + Structure")

import threading
from typing import Dict, Record, Any

class EventProcessor:
    """
    Thread-safe occasion processor that aggregates person occasions in reminiscence.
    Validates enter strictly and helps straightforward extension for brand spanking new occasion sorts.
    """
    
    def __init__(self) -> None:
        # Shops occasions per person: user_id -> checklist of occasion dictionaries
        self._user_events: Dict[str, List[Dict[str, Any]]] = {}
        # Lock for thread-safe entry
        self._lock = threading.Lock()
    
    def ingest_event(self, occasion: dict) -> None:
        """
        Validate and ingest a single occasion.
        Strictly validates sorts and presence of required keys.
        """
        # Validate occasion is a dictionary
        if not isinstance(occasion, dict):
            elevate ValueError("Occasion have to be a dictionary")
        
        # Validate required keys and their sorts
        required_keys = {
            'user_id': str,
            'event_type': str,
            'timestamp': (str, int, float)  # Settle for string or numeric timestamp
        }
        
        for key, expected_type in required_keys.objects():
            if key not in occasion:
                elevate ValueError(f"Lacking required key: '{key}'")
            if not isinstance(occasion[key], expected_type):
                elevate ValueError(f"Key '{key}' have to be of kind {expected_type.__name__}")
        
        # Thread-safe occasion storage
        with self._lock:
            user_id = occasion['user_id']
            if user_id not in self._user_events:
                self._user_events[user_id] = []
            self._user_events[user_id].append(occasion)
    
    def get_user_summary(self, user_id: str) -> dict:
        """
        Generate abstract for a selected person.
        Returns aggregated occasion counts and timestamps.
        """
        if not isinstance(user_id, str):
            elevate ValueError("user_id have to be a string")
        
        with self._lock:
            user_events = self._user_events.get(user_id, [])
            
            # Mixture occasion counts
            event_counts = {}
            timestamps = []
            
            for occasion in user_events:
                event_type = occasion['event_type']
                event_counts[event_type] = event_counts.get(event_type, 0) + 1
                timestamps.append(occasion['timestamp'])
            
            return {
                'user_id': user_id,
                'total_events': len(user_events),
                'event_counts': event_counts,
                'timestamps': sorted(timestamps) if timestamps else []
            }
```

**Key Design Selections:**

1. **Thread Security**: Makes use of `threading.Lock` to guard shared state throughout concurrent entry
2. **Enter Validation**: Strict kind checking for required keys with clear error messages
3. **Extensibility**: 
   - New occasion sorts robotically dealt with by dynamic counting
   - Simple so as to add new aggregations in `get_user_summary`
4. **Testability**: Clear separation of considerations, straightforward to mock for unit checks
5. **Reminiscence Effectivity**: Shops solely important information (occasion dictionaries)

**Utilization Instance:**
```python
processor = EventProcessor()

# Ingest occasions
processor.ingest_event({
    'user_id': 'user123',
    'event_type': 'login',
    'timestamp': '2023-01-01T10:00:00Z'
})

# Get person abstract
abstract = processor.get_user_summary('user123')
print(abstract)

import anthropic
import json

shopper = anthropic.Anthropic()

def get_stock_metrics(ticker):
    information = {
        "NVDA": {"value": 130, "pe": 75.2},
        "AMD": {"value": 150, "pe": 40.5}
    }
    return json.dumps(information.get(ticker, "Ticker not discovered"))

def get_sentiment_analysis(company_name):
    sentiments = {"NVIDIA": 0.85, "AMD": 0.42}
    return f"Sentiment rating for {company_name}: {sentiments.get(company_name, 0.0)}"

instruments = [
    {
        "name": "get_stock_metrics",
        "description": "Get price and P/E ratio.",
        "input_schema": {
            "type": "object",
            "properties": {"ticker": {"type": "string"}},
            "required": ["ticker"]
        }
    },
    {
        "title": "get_sentiment_analysis",
        "description": "Get information sentiment rating.",
        "input_schema": {
            "kind": "object",
            "properties": {"company_name": {"kind": "string"}},
            "required": ["company_name"]
        }
    }
]

messages = [{"role": "user", "content": "Compare NVDA and AMD value based on P/E and sentiment."}]
operating = True

print(f"👤 [USER]: {messages[0]['content']}")

whereas operating:
    # Get mannequin response
    response = shopper.messages.create(
        mannequin="MiniMax-M2.1",
        max_tokens=4096,
        messages=messages,
        instruments=instruments,
    )

    messages.append({"function": "assistant", "content material": response.content material})

    tool_results = []
    has_tool_use = False

    for block in response.content material:
        if block.kind == "pondering":
            print(f"n💭 [THINKING]:n{block.pondering}")
        
        elif block.kind == "textual content":
            print(f"n💬 [MODEL]: {block.textual content}")
            if not any(b.kind == "tool_use" for b in response.content material):
                operating = False
        
        elif block.kind == "tool_use":
            has_tool_use = True
            print(f"🔧 [TOOL CALL]: {block.title}({block.enter})")
            
            # Execute the right mock operate
            if block.title == "get_stock_metrics":
                end result = get_stock_metrics(block.enter['ticker'])
            elif block.title == "get_sentiment_analysis":
                end result = get_sentiment_analysis(block.enter['company_name'])
            
            # Add to the outcomes checklist for this flip
            tool_results.append({
                "kind": "tool_result",
                "tool_use_id": block.id,
                "content material": end result
            })

    if has_tool_use:
        messages.append({"function": "person", "content material": tool_results})
    else:
        operating = False

print("n✅ Dialog Full.")

import os
from getpass import getpass
os.environ['OPENAI_API_KEY'] = getpass ('Enter OpenAI API Key: ')

input_text = """
¡Preparar café Chilly Brew es un proceso sencillo y refrescante!
Todo lo que necesitas son granos de café molido grueso y agua fría.
Comienza añadiendo el café molido a un recipiente o jarra grande.
Luego, vierte agua fría, asegurándote de que todos los granos de café
estén completamente sumergidos.
Remueve la mezcla suavemente para garantizar una saturación uniforme.
Cubre el recipiente y déjalo en remojo en el refrigerador durante al
menos 12 a 24 horas, dependiendo de la fuerza deseada.
"""

immediate = f"""
The next textual content is written in Spanish.

Job:
1. Determine all phrases within the textual content which might be associated to espresso or espresso preparation.
2. Translate ONLY these phrases into English.
3. Take away duplicates (every phrase ought to seem solely as soon as).
4. Current the end result as a numbered checklist.

Guidelines:
- Do NOT embody explanations.
- Do NOT embody non-coffee-related phrases.
- Do NOT embody Spanish phrases within the last output.

Textual content:
<{input_text}>
"""

from openai import OpenAI
shopper = OpenAI()

response = shopper.responses.create(
    mannequin="gpt-5.2",
    enter=immediate
)

print(response.output_text)

import anthropic

shopper = anthropic.Anthropic()

message = shopper.messages.create(
    mannequin="MiniMax-M2.1",
    max_tokens=10000,
    system="You're a useful assistant.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": prompt
                }
            ]
        }
    ]
)

for block in message.content material:
    if block.kind == "pondering":
        print(f"Considering:n{block.pondering}n")
    elif block.kind == "textual content":
        print(f"Textual content:n{block.textual content}n")