MiniMax releases M2.1: enhanced M2 model with options akin to 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"Pondering:n{block.pondering}n")
    elif block.kind == "textual content":
        print(f"Textual content:n{block.textual content}n")

Pondering:
The consumer is simply asking how I'm doing. This can be a pleasant greeting, so I ought to reply in a heat, conversational means. I will maintain it easy and pleasant.

Textual content:
Hello! I am doing properly, 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 ample 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("🧠 Pondering:n", block.pondering, "n")
        elif block.kind == "textual content":
            print("📄 Output:n", block.textual content, "n")

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

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

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

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

import threading
from typing import Dict, Listing, Any

class EventProcessor:
    """
    Thread-safe occasion processor that aggregates consumer occasions in reminiscence.
    Validates enter strictly and helps straightforward extension for brand spanking new occasion varieties.
    """
    
    def __init__(self) -> None:
        # Shops occasions per consumer: user_id -> listing 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 varieties and presence of required keys.
        """
        # Validate occasion is a dictionary
        if not isinstance(occasion, dict):
            increase ValueError("Occasion should be a dictionary")
        
        # Validate required keys and their varieties
        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:
                increase ValueError(f"Lacking required key: '{key}'")
            if not isinstance(occasion[key], expected_type):
                increase ValueError(f"Key '{key}' should 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 particular consumer.
        Returns aggregated occasion counts and timestamps.
        """
        if not isinstance(user_id, str):
            increase ValueError("user_id should 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 varieties robotically dealt with by dynamic counting
   - Simple so as to add new aggregations in `get_user_summary`
4. **Testability**: Clear separation of issues, straightforward to mock for unit assessments
5. **Reminiscence Effectivity**: Shops solely important knowledge (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 consumer abstract
abstract = processor.get_user_summary('user123')
print(abstract)

import anthropic
import json

shopper = anthropic.Anthropic()

def get_stock_metrics(ticker):
    knowledge = {
        "NVDA": {"worth": 130, "pe": 75.2},
        "AMD": {"worth": 150, "pe": 40.5}
    }
    return json.dumps(knowledge.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({"position": "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 proper 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 listing for this flip
            tool_results.append({
                "kind": "tool_result",
                "tool_use_id": block.id,
                "content material": end result
            })

    if has_tool_use:
        messages.append({"position": "consumer", "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 are 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 listing.

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"Pondering:n{block.pondering}n")
    elif block.kind == "textual content":
        print(f"Textual content:n{block.textual content}n")