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

Pondering:
The consumer is simply asking how I'm doing. It is a pleasant greeting, so I ought to reply in a heat, conversational approach. I will preserve it easy and pleasant.

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

I am prepared that can assist you with no matter you want at present. Whether or not it is coding, answering questions, brainstorming concepts, or simply chatting, I am right here for you.

What can I enable you 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, "
            "express 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.sort == "considering":
            print("🧠 Pondering:n", block.considering, "n")
        elif block.sort == "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 (sorts + 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 have to be:
   - Testable
   - Thread-safe
   - Simply extensible for brand spanking new occasion sorts
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 simple extension for brand spanking new occasion sorts.
    """
    
    def __init__(self) -> None:
        # Shops occasions per consumer: user_id -> record 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):
            increase 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.gadgets():
            if key not in occasion:
                increase ValueError(f"Lacking required key: '{key}'")
            if not isinstance(occasion[key], expected_type):
                increase ValueError(f"Key '{key}' have to be of sort {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 consumer.
        Returns aggregated occasion counts and timestamps.
        """
        if not isinstance(user_id, str):
            increase 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 sort checking for required keys with clear error messages
3. **Extensibility**: 
   - New occasion sorts robotically dealt with by dynamic counting
   - Straightforward so as to add new aggregations in `get_user_summary`
4. **Testability**: Clear separation of issues, simple 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 consumer abstract
abstract = processor.get_user_summary('user123')
print(abstract)

import anthropic
import json

shopper = anthropic.Anthropic()

def get_stock_metrics(ticker):
    information = {
        "NVDA": {"worth": 130, "pe": 75.2},
        "AMD": {"worth": 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"]
        }
    },
    {
        "identify": "get_sentiment_analysis",
        "description": "Get information sentiment rating.",
        "input_schema": {
            "sort": "object",
            "properties": {"company_name": {"sort": "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.sort == "considering":
            print(f"n💭 [THINKING]:n{block.considering}")
        
        elif block.sort == "textual content":
            print(f"n💬 [MODEL]: {block.textual content}")
            if not any(b.sort == "tool_use" for b in response.content material):
                operating = False
        
        elif block.sort == "tool_use":
            has_tool_use = True
            print(f"🔧 [TOOL CALL]: {block.identify}({block.enter})")
            
            # Execute the right mock perform
            if block.identify == "get_stock_metrics":
                consequence = get_stock_metrics(block.enter['ticker'])
            elif block.identify == "get_sentiment_analysis":
                consequence = get_sentiment_analysis(block.enter['company_name'])
            
            # Add to the outcomes record for this flip
            tool_results.append({
                "sort": "tool_result",
                "tool_use_id": block.id,
                "content material": consequence
            })

    if has_tool_use:
        messages.append({"function": "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.

Activity:
1. Determine all phrases within the textual content which can 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 consequence as a numbered record.

Guidelines:
- Do NOT embody explanations.
- Do NOT embody non-coffee-related phrases.
- Do NOT embody Spanish phrases within the ultimate 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.sort == "considering":
        print(f"Pondering:n{block.considering}n")
    elif block.sort == "textual content":
        print(f"Textual content:n{block.textual content}n")