pip install anthropic

import anthropic

client = anthropic.Anthropic(api_key="your-api-key")

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    system="你是AI创业内参的写手，风格专业、有数据支撑、实操导向。",
    messages=[
        {"role": "user", "content": "写一篇关于Claude Opus 5定价策略的深度分析"}
    ]
)

print(response.content[0].text)
print(f"Token使用: 输入{response.usage.input_tokens}, 输出{response.usage.output_tokens}")

Token使用: 输入1247, 输出3856

Opus 5 的定价策略可以用一句话概括：在旧价格上提供新能力...

{
  "model": "claude-opus-5",
  "maxTokens": 8192,
  "temperature": 0.7
}

claude --model claude-opus-5 "解释这个函数的复杂度，并给出优化方案" 

providers:
  anthropic:
    api_key: "your-anthropic-key"
    base_url: "api.anthropic.com"

models:
  - provider: anthropic
    model: "claude-opus-5"
    name: "Opus 5"

import anthropic

client = anthropic.Anthropic(api_key="your-key")

# 这些内容会被自动缓存
SYSTEM_PROMPT = """你是AI创业内参的写手。目标读者是AI创业者。
写作要求：数据驱动、实操导向、每段不超过200字。"""

BRAND_GUIDE = """品牌调性：专业但不学术，有观点但不偏激。
文章结构：事件回顾→为什么重要→实操建议→总结。"""

# 每次变化的用户请求放在最后
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    system=SYSTEM_PROMPT + "\n" + BRAND_GUIDE,
    messages=[{
        "role": "user",
        "content": "今天的热点是Claude Opus 5发布，写一篇分析"
    }]
)

# 检查缓存命中情况
print(f"输入tokens: {response.usage.input_tokens}")
print(f"缓存写入: {response.usage.cache_creation_input_tokens}")
print(f"缓存读取: {response.usage.cache_read_input_tokens}")

输入tokens: 2847
缓存写入: 0
缓存读取: 2341

import anthropic
import time

client = anthropic.Anthropic(api_key="your-key")

# 创建一个批量请求
batch = client.beta.messages.batches.create(
    requests=[
        {
            "custom_id": "topic-1",
            "params": {
                "model": "claude-opus-5",
                "max_tokens": 2048,
                "messages": [{"role": "user", "content": "生成3个AI创业选题"}]
            }
        },
        {
            "custom_id": "topic-2",
            "params": {
                "model": "claude-opus-5",
                "max_tokens": 2048,
                "messages": [{"role": "user", "content": "生成3个AI工具赛道选题"}]
            }
        },
        {
            "custom_id": "translate-1",
            "params": {
                "model": "claude-opus-5",
                "max_tokens": 4096,
                "messages": [{"role": "user", "content": "翻译：Hacker News today's top 10 AI posts"}]
            }
        }
    ]
)

print(f"Batch ID: {batch.id}")
print(f"状态: {batch.processing_status}")

# 等待完成（通常几分钟到几小时）
# 在生产环境中，这个等待通常放在后端任务里，用轮询或 webhook
# 你的主程序可以继续处理其他事情，不需要在这里阻塞等待
while batch.processing_status not in ("ended", "failed"):
    time.sleep(60)
    batch = client.beta.messages.batches.retrieve(batch.id)
    print(f"状态: {batch.processing_status}")

# 获取结果
if batch.processing_status == "ended":
    for result in client.beta.messages.batches.results(batch.id):
        if result.result.type == "succeeded":
            text = result.result.message.content[0].text
            print(f"[{result.custom_id}] {text[:100]}...")
        else:
            print(f"[{result.custom_id}] 失败: {result.result.error}")

def call_with_effort(prompt, effort="medium"):
    """用不同 effort level 调用 Opus 5"""

    # 在 system prompt 中指定 effort（API 层面的支持）
    system_prompt = ""
    if effort == "low":
        system_prompt = "请用最简洁的方式回答，跳过不必要的分析步骤。"
    elif effort == "high":
        system_prompt = "请深度分析，考虑所有可能的角度和边界情况。"

    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        system=system_prompt,
        messages=[{"role": "user", "content": prompt}]
    )

    return {
        "text": response.content[0].text,
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens,
        "cost": (response.usage.input_tokens * 5 + response.usage.output_tokens * 25) / 1_000_000
    }

# 对比三种 effort level
for effort in ["low", "medium", "high"]:
    result = call_with_effort("分析Claude Opus 5对AI创业的影响", effort)
    print(f"{effort}: {result['output_tokens']} tokens, ${result['cost']:.4f}")

low: 847 tokens, $0.0256
medium: 1856 tokens, $0.0521
high: 3201 tokens, $0.0863

#!/usr/bin/env python3
"""Opus 5 内容生产 Agent — 夜间批处理模式"""
import anthropic, json, time
from datetime import datetime

client = anthropic.Anthropic()

SYSTEM = """你是AI创业内参的内容Agent。目标读者：AI创业者。
风格：数据驱动、实操导向、有代码有案例。
输出格式：Markdown，含对比表格、代码块、踩坑提醒。"""

def generate_topics():
    """夜间批处理：生成明天选题"""
    requests = []
    categories = ["AI Agent工具", "行业动态", "一人公司方法论"]
    for i, cat in enumerate(categories):
        requests.append({
            "custom_id": f"topic-{i}",
            "params": {
                "model": "claude-opus-5",
                "max_tokens": 1024,
                "system": SYSTEM,
                "messages": [{"role": "user", "content": f"生成3个{cat}赛道的选题，每个选题包含标题和一段核心观点"}]
            }
        })

    batch = client.beta.messages.batches.create(requests=requests)
    print(f"✓ 选题batch已提交: {batch.id}")
    return batch.id

def write_article(topic):
    """白天：实时写一篇深度文章"""
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=8192,
        system=SYSTEM + "\n写作要求：2500-4000字，包含至少3个代码示例、2个表格、3处踩坑提醒。",
        messages=[{"role": "user", "content": f"写一篇Agent工坊教程：{topic}"}]
    )

    text = response.content[0].text
    cost = (response.usage.input_tokens * 5 + response.usage.output_tokens * 25) / 1_000_000
    print(f"✓ 文章生成: {len(text)}字符, ${cost:.4f}")
    return text

# 使用示例
if __name__ == "__main__":
    batch_id = generate_topics()
    # ... 第二天早上拿结果 ...
    article = write_article("Claude Opus 5实战接入指南")

def estimate_monthly_cost(
    articles_per_day=5,
    avg_input_tokens=3000,
    avg_output_tokens=4000,
    cache_hit_rate=0.6,
    batch_ratio=0.3
):
    """估算月度 Opus 5 成本"""

    days = 30
    total = articles_per_day * days

    # 基础价格
    base_input_cost = avg_input_tokens / 1_000_000 * 5
    base_output_cost = avg_output_tokens / 1_000_000 * 25
    base_per_article = base_input_cost + base_output_cost

    # 缓存带来的输入节省
    cached_saving = base_input_cost * cache_hit_rate * (1 - 0.1)  # 缓存命中省90%

    # 批处理带来的全部节省
    batch_saving = base_per_article * batch_ratio * 0.5  # Batch API减半

    effective_per_article = base_per_article - cached_saving - batch_saving
    monthly = effective_per_article * total

    print(f"=" * 50)
    print(f"Claude Opus 5 月度成本估算")
    print(f"=" * 50)
    print(f"每日文章数: {articles_per_day}")
    print(f"平均输入/输出 tokens: {avg_input_tokens}/{avg_output_tokens}")
    print(f"缓存命中率: {cache_hit_rate*100:.0f}%")
    print(f"批处理占比: {batch_ratio*100:.0f}%")
    print(f"-" * 50)
    print(f"基础每篇成本: ${base_per_article:.4f}")
    print(f"缓存节省/篇:  ${cached_saving:.4f}")
    print(f"批处理节省/篇: ${batch_saving:.4f}")
    print(f"实际每篇成本: ${effective_per_article:.4f}")
    print(f"=" * 50)
    print(f"月度总成本:   ${monthly:.2f}")
    print(f"日均成本:     ${monthly/days:.2f}")
    print(f"## 如果不用缓存和批处理: ${base_per_article * total:.2f}")
    print(f"## 省了: ${base_per_article * total - monthly:.2f}")
    return monthly

# 典型场景
estimate_monthly_cost(
    articles_per_day=5,
    avg_input_tokens=3000,
    avg_output_tokens=4000,
    cache_hit_rate=0.6,
    batch_ratio=0.3
)

==================================================
Claude Opus 5 月度成本估算
==================================================
每日文章数: 5
平均输入/输出 tokens: 3000/4000
缓存命中率: 60%
批处理占比: 30%
--------------------------------------------------
基础每篇成本: $0.1150
缓存节省/篇:  $0.0081
批处理节省/篇: $0.0172
实际每篇成本: $0.0897
==================================================
月度总成本:   $13.45
日均成本:     $0.45
## 如果不用缓存和批处理: $17.25
## 省了: $3.80