☰ 速查表

import anthropic

client = anthropic.Anthropic(api_key="YOUR_API_KEY")  # 也可读取环境变量 ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ]
)

print(message.content[0].text)
# message.stop_reason  -> "end_turn" | "max_tokens" | "tool_use" | "stop_sequence"
# message.usage.input_tokens / output_tokens

message = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    system="You are a helpful assistant.",  # 顶级参数
    messages=[{"role": "user", "content": "Hi"}]
)

messages = []

# 第一轮
messages.append({"role": "user", "content": "What is 2+2?"})
resp = client.messages.create(model="claude-opus-4-5", max_tokens=256, messages=messages)
messages.append({"role": "assistant", "content": resp.content[0].text})

# 第二轮
messages.append({"role": "user", "content": "Multiply that by 3."})
resp2 = client.messages.create(model="claude-opus-4-5", max_tokens=256, messages=messages)
print(resp2.content[0].text)

with client.messages.stream(
    model="claude-opus-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Tell me a story"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns temperature and conditions.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    }
]

import anthropic, json

client = anthropic.Anthropic()

def get_weather(city: str, unit: str = "celsius") -> str:
    return json.dumps({"city": city, "temp": 22, "conditions": "sunny", "unit": unit})

tools = [{
    "name": "get_weather",
    "description": "Get current weather for a city.",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
    }
}]

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

# 第一次调用
resp = client.messages.create(
    model="claude-opus-4-5", max_tokens=1024,
    tools=tools, messages=messages
)

if resp.stop_reason == "tool_use":
    # 提取 tool_use 块
    tool_block = next(b for b in resp.content if b.type == "tool_use")
    tool_name = tool_block.name
    tool_input = tool_block.input

    # 执行工具
    result = get_weather(**tool_input)

    # 构建 tool_result 消息
    messages.append({"role": "assistant", "content": resp.content})
    messages.append({
        "role": "user",
        "content": [{
            "type": "tool_result",
            "tool_use_id": tool_block.id,
            "content": result
        }]
    })

    # 第二次调用获取最终答案
    final = client.messages.create(
        model="claude-opus-4-5", max_tokens=1024,
        tools=tools, messages=messages
    )
    print(final.content[0].text)

import anthropic

client = anthropic.Anthropic()

LONG_SYSTEM_PROMPT = "..." * 500  # 假设很长的系统提示

message = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": LONG_SYSTEM_PROMPT,
            "cache_control": {"type": "ephemeral"}  # 缓存断点
        }
    ],
    messages=[{"role": "user", "content": "Summarize your instructions."}]
)

print(message.usage)
# cache_creation_input_tokens: N (首次)
# cache_read_input_tokens: N (后续命中)

tools_with_cache = [
    {
        "name": "tool_one",
        "description": "...",
        "input_schema": {"type": "object", "properties": {}}
    },
    # ... 更多工具
    {
        "name": "last_tool",
        "description": "...",
        "input_schema": {"type": "object", "properties": {}},
        "cache_control": {"type": "ephemeral"}  # 在最后一个工具后打断点
    }
]

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # 允许最多 10k token 用于思考
    },
    messages=[{
        "role": "user",
        "content": "Prove that sqrt(2) is irrational."
    }]
)

for block in response.content:
    if block.type == "thinking":
        print("=== Internal Thinking ===")
        print(block.thinking)
    elif block.type == "text":
        print("=== Final Answer ===")
        print(block.text)

# 为每个 chunk 生成上下文
def contextualize_chunk(full_doc: str, chunk: str) -> str:
    resp = client.messages.create(
        model="claude-haiku-3-5",
        max_tokens=100,
        system="Generate a concise context (1-2 sentences) for the following chunk within the full document.",
        messages=[{
            "role": "user",
            "content": f"<document>{full_doc}</document>\n<chunk>{chunk}</chunk>"
        }]
    )
    context = resp.content[0].text
    return f"{context}\n\n{chunk}"  # 上下文 + 原文

import asyncio
import anthropic

client = anthropic.AsyncAnthropic()

async def analyze(text: str) -> str:
    resp = await client.messages.create(
        model="claude-haiku-3-5", max_tokens=256,
        messages=[{"role": "user", "content": f"Summarize: {text}"}]
    )
    return resp.content[0].text

async def main(documents: list[str]):
    results = await asyncio.gather(*[analyze(doc) for doc in documents])
    return results

from mcp.server.fastmcp import FastMCP

# 创建 MCP Server 实例
mcp = FastMCP("my-server")

if __name__ == "__main__":
    mcp.run()  # 默认使用 stdio transport

from mcp.server.fastmcp import FastMCP
import httpx

mcp = FastMCP("weather-server")

@mcp.tool()
async def get_weather(city: str, unit: str = "celsius") -> str:
    """Get current weather for a city.

    Args:
        city: Name of the city
        unit: Temperature unit (celsius or fahrenheit)
    """
    # FastMCP 自动从类型注解生成 JSON Schema
    async with httpx.AsyncClient() as client:
        resp = await client.get(f"https://api.weather.example.com/{city}")
        data = resp.json()
    return f"{city}: {data['temp']}°{unit[0].upper()}, {data['conditions']}"

from mcp.server.fastmcp import FastMCP
from mcp.types import Resource

mcp = FastMCP("file-server")

# 静态资源
@mcp.resource("file://config.json")
def get_config() -> str:
    """Return application configuration."""
    with open("config.json") as f:
        return f.read()

# 动态资源（模板）
@mcp.resource("user://{user_id}/profile")
def get_user_profile(user_id: str) -> str:
    """Fetch user profile by ID."""
    return f"Profile for user {user_id}"

from mcp.server.fastmcp import FastMCP
from mcp.types import GetPromptResult, PromptMessage, TextContent

mcp = FastMCP("prompt-server")

@mcp.prompt()
def code_review(language: str, code: str) -> list[PromptMessage]:
    """Generate a code review prompt."""
    return [
        PromptMessage(
            role="user",
            content=TextContent(
                type="text",
                text=f"Please review this {language} code:\n\n```{language}\n{code}\n```"
            )
        )
    ]

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("demo")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

if __name__ == "__main__":
    import sys
    if "--sse" in sys.argv:
        mcp.run(transport="sse", host="0.0.0.0", port=8080)
    else:
        mcp.run(transport="stdio")

{
  "mcpServers": {
    "my-weather": {
      "command": "python",
      "args": ["/path/to/weather_server.py"],
      "env": {
        "WEATHER_API_KEY": "your-key"
      }
    },
    "remote-server": {
      "url": "http://localhost:8080/sse"
    }
  }
}

---
name: code-review
description: |
  Perform a comprehensive code review of the current file or selection.
  Trigger when user asks to review code, check code quality, or find bugs.
allowed-tools:
  - Read
  - Bash
argument-hint: "[file path or 'current']"
version: "1.0.0"
---

# Code Review Skill

When activated, perform the following steps:

1. Read the target file(s) using the Read tool
2. Analyze for: bugs, security issues, performance, style
3. Run linting if available: `npm run lint` or `ruff check`
4. Output findings in this format:

## Critical Issues
[List blocking bugs]

## Suggestions
[List improvements]

## Summary
[Overall assessment]

{
  "skills": {
    "code-review": {
      "enabled": true,
      "allowed-tools": ["Read", "Bash", "Glob", "Grep"]
    },
    "deploy": {
      "enabled": false  // 在此项目中禁用部署技能
    }
  },
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(ruff check *)"
    ]
  }
}

# .claude/commands/fix-tests.md
Find all failing tests, diagnose the root cause, and fix them.

Arguments: $ARGUMENTS

Steps:
1. Run: npm test 2>&1 | tail -50
2. Identify failing test files
3. Read the failing tests and related source files
4. Fix the implementation (not the tests unless tests are wrong)
5. Verify: npm test