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

consumer = anthropic.Anthropic()

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

Pondering:
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 will hold it easy and pleasant.

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

I am prepared that can assist you with no matter you want immediately. 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

consumer = anthropic.Anthropic()

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

    message = consumer.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 adequate reasoning. "
            "Keep away from pointless verbosity."
        ),
        messages=[
            {
                "role": "user",
                "content": [{"type": "text", "text": prompt}]
            }
        ]
    )

    for block in message.content material:
        if block.kind == "considering":
            print("🧠 Pondering:n", block.considering, "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 (varieties + 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 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, 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 varieties.
    """
    
    def __init__(self) -> None:
        # Shops occasions per person: 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):
            elevate 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.gadgets():
            if key not in occasion:
                elevate ValueError(f"Lacking required key: '{key}'")
            if not isinstance(occasion[key], expected_type):
                elevate 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 person.
        Returns aggregated occasion counts and timestamps.
        """
        if not isinstance(user_id, str):
            elevate 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 mechanically dealt with by dynamic counting
   - Straightforward so as to add new aggregations in `get_user_summary`
4. **Testability**: Clear separation of issues, straightforward to mock for unit exams
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

consumer = 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."}]
working = True

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

whereas working:
    # Get mannequin response
    response = consumer.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 == "considering":
            print(f"n💭 [THINKING]:n{block.considering}")
        
        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):
                working = False
        
        elif block.kind == "tool_use":
            has_tool_use = True
            print(f"🔧 [TOOL CALL]: {block.title}({block.enter})")
            
            # Execute the right mock perform
            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": "person", "content material": tool_results})
    else:
        working = 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.

Process:
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 closing output.

Textual content:
<{input_text}>
"""

from openai import OpenAI
consumer = OpenAI()

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

print(response.output_text)

import anthropic

consumer = anthropic.Anthropic()

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