import contextvars
import json
from typing import Any
import anthropic

# コンテキスト変数でエージェントの状態を管理
agent_state: contextvars.ContextVar[dict] = contextvars.ContextVar(
    'agent_state', default={}
)

def store_large_data(key: str, data: Any) -> str:
    """
    大規模データをagent.stateに格納し、ポインタ文字列を返す
    214KB → 52バイト程度のポインタへ圧縮
    """
    current_state = agent_state.get().copy()
    current_state[key] = data
    agent_state.set(current_state)

    # コンテキストには短いポインタのみ渡す
    pointer = f"[STATE_REF:{key}]"
    return pointer

def retrieve_from_state(pointer: str) -> Any:
    """ポインタから実データを取得"""
    if pointer.startswith("[STATE_REF:") and pointer.endswith("]"):
        key = pointer[11:-1]
        return agent_state.get().get(key, None)
    return pointer

def run_memory_pointer_agent(user_query: str):
    """メモリポインターパターンを使ったエージェント"""
    client = anthropic.Anthropic()

    # 大規模DBクエリ結果をシミュレート（本来は何万行ものデータ）
    large_db_result = {
        "rows": [{"id": i, "value": f"data_{i}", "metadata": "x" * 100}
                 for i in range(1000)],
        "total": 1000,
        "schema": {"id": "int", "value": "str", "metadata": "str"}
    }

    # 大規模データをstateに格納してポインタを取得
    pointer = store_large_data("db_result", large_db_result)

    # コンテキストにはポインタのみ（52バイト程度）
    context_message = f"""
    データベースクエリ結果: {pointer}
    サマリー: 1000件のレコードを取得済み。必要に応じてSTATE_REFから参照可能。
    ユーザーの質問: {user_query}
    """

    print(f"コンテキストサイズ: {len(context_message)}バイト（元データ: {len(json.dumps(large_db_result))}バイト）")

    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        system="あなたはデータ分析エージェントです。[STATE_REF:key]形式のポインタが示すデータについて、サマリー情報をもとに回答してください。",
        messages=[{"role": "user", "content": context_message}]
    )

    return response.content[0].text

if __name__ == "__main__":
    result = run_memory_pointer_agent("データの件数と構造を教えてください")
    print(result)

import numpy as np
from typing import List, Dict
import anthropic

class SimpleVectorStore:
    def __init__(self):
        self.documents: List[Dict] = []
        self.embeddings: List[np.ndarray] = []

    def add_document(self, text: str, metadata: dict = None):
        """ドキュメントを追加（本番では埋め込みモデルAPIを使用）"""
        np.random.seed(hash(text) % 2**32)
        embedding = np.random.rand(128)
        embedding = embedding / np.linalg.norm(embedding)
        self.documents.append({"text": text, "metadata": metadata or {}})
        self.embeddings.append(embedding)

    def search(self, query: str, top_k: int = 3) -> List[Dict]:
        """クエリに類似したドキュメントを返す"""
        if not self.documents:
            return []

        np.random.seed(hash(query) % 2**32)
        query_embedding = np.random.rand(128)
        query_embedding = query_embedding / np.linalg.norm(query_embedding)

        similarities = [
            np.dot(query_embedding, emb)
            for emb in self.embeddings
        ]

        top_indices = np.argsort(similarities)[-top_k:][::-1]
        return [self.documents[i] for i in top_indices]


def run_rag_jit_agent(user_query: str):
    """RAGジャストインタイム注入パターンを使ったエージェント"""
    client = anthropic.Anthropic()

    store = SimpleVectorStore()
    store.add_document(
        "コンテキストエンジニアリングはLLMの推論品質を決定する重要な技術です。",
        {"source": "technical_doc", "chunk_size": "small"}
    )
    store.add_document(
        "RAGのチャンクサイズは用途によって使い分ける必要があります。"
        "精度優先なら128〜256トークン、文脈優先なら512〜1024トークンが適切です。",
        {"source": "best_practices", "chunk_size": "medium"}
    )
    store.add_document(
        "Lost-in-the-Middleは長いコンテキストで中間の情報が無視される現象です。"
        "重要情報は先頭または末尾に配置することで軽減できます。",
        {"source": "research", "chunk_size": "medium"}
    )

    # 実行時にのみ関連情報を取得（ジャストインタイム）
    relevant_docs = store.search(user_query, top_k=2)
    context = "\n\n".join([doc["text"] for doc in relevant_docs])

    print(f"取得したチャンク数: {len(relevant_docs)}件（全{len(store.documents)}件中）")

    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        system="あなたは技術的な質問に答えるエージェントです。提供されたコンテキスト情報を参照して回答してください。",
        messages=[{
            "role": "user",
            "content": f"コンテキスト情報:\n{context}\n\n質問: {user_query}"
        }]
    )

    return response.content[0].text


if __name__ == "__main__":
    result = run_rag_jit_agent("RAGのチャンクサイズはどう選べばよいですか？")
    print(result)

from typing import List, Dict, Tuple
import anthropic

MAX_RAW_TURNS = 6       # これを超えたら古いターンを要約する
COMPRESS_KEEP_TURNS = 2 # 要約後に生のまま残す最新ターン数


def summarize_turns(client: anthropic.Anthropic, turns: List[Dict]) -> str:
    """古い会話ターン群をAIで要約する"""
    conversation_text = ""
    for turn in turns:
        role = "ユーザー" if turn["role"] == "user" else "アシスタント"
        conversation_text += f"{role}: {turn['content']}\n\n"

    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=512,
        system=(
            "あなたは会話履歴の要約専門家です。"
            "以下の会話から重要な意思決定・制約条件・前提事項を漏らさず、"
            "簡潔な箇条書きで要約してください。"
        ),
        messages=[{
            "role": "user",
            "content": f"以下の会話履歴を要約してください:\n\n{conversation_text}"
        }]
    )
    return response.content[0].text


def compress_history(
    client: anthropic.Anthropic,
    messages: List[Dict],
    summary_so_far: str = ""
) -> Tuple[List[Dict], str]:
    """
    メッセージ履歴が閾値を超えたら古いターンを要約圧縮する。
    戻り値: (圧縮後のメッセージリスト, 更新済み要約文字列)
    """
    if len(messages) <= MAX_RAW_TURNS:
        return messages, summary_so_far

    old_turns = messages[:-COMPRESS_KEEP_TURNS]
    recent_turns = messages[-COMPRESS_KEEP_TURNS:]

    new_summary_piece = summarize_turns(client, old_turns)

    if summary_so_far:
        updated_summary = f"{summary_so_far}\n\n【追加要約】\n{new_summary_piece}"
    else:
        updated_summary = new_summary_piece

    print(f"圧縮前: {len(messages)}ターン → 圧縮後: {COMPRESS_KEEP_TURNS}ターン（要約保持）")
    return recent_turns, updated_summary


def run_compressed_memory_agent(user_inputs: List[str]) -> List[str]:
    """階層的要約圧縮パターンを使った長期タスクエージェント"""
    client = anthropic.Anthropic()
    messages: List[Dict] = []
    summary: str = ""
    responses: List[str] = []

    for user_input in user_inputs:
        messages, summary = compress_history(client, messages, summary)

        system_prompt = "あなたは長期タスクを支援するエージェントです。"
        if summary:
            system_prompt += f"\n\n【これまでの会話要約】\n{summary}"

        messages.append({"role": "user", "content": user_input})

        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=512,
            system=system_prompt,
            messages=messages
        )

        assistant_reply = response.content[0].text
        messages.append({"role": "assistant", "content": assistant_reply})
        responses.append(assistant_reply)

        print(f"現在のコンテキストターン数: {len(messages)}, 要約長: {len(summary)}文字")

    return responses


if __name__ == "__main__":
    conversation = [
        "今日のタスクはデータパイプラインの設計です。予算上限は50万円でお願いします。",
        "使用するDBはPostgreSQLで、スキーマはusers・orders・productsの3テーブルです。",
        "バッチ処理は毎日深夜2時に実行する方針にしましょう。",
        "エラーハンドリングはリトライ3回、その後Slackに通知する設計にしてください。",
        "ログはCloudWatchに集約して、7日間保持の方針でお願いします。",
        "モニタリングはDatadogを使います。アラートのしきい値は処理時間30分超えで。",
        "ここまでの設計内容をまとめてください。予算内に収まっていますか？",
    ]

    results = run_compressed_memory_agent(conversation)
    print("\n最終応答:")
    print(results[-1])

from typing import Dict, Any
import anthropic


def create_scoped_client() -> anthropic.Anthropic:
    """Anthropicクライアントを生成する"""
    return anthropic.Anthropic()


def search_subagent(client: anthropic.Anthropic, query: str) -> str:
    """検索専用サブエージェント: 検索ツールのみ保持"""
    tools = [
        {
            "name": "web_search",
            "description": "指定されたクエリでWeb検索を行い結果を返す",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "検索クエリ"}
                },
                "required": ["query"]
            }
        }
    ]

    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=512,
        system="あなたは検索専門エージェントです。与えられたクエリを検索し、結果を返してください。",
        tools=tools,
        messages=[{"role": "user", "content": f"次のクエリで検索してください: {query}"}]
    )

    if response.stop_reason == "tool_use":
        return f"[検索結果] '{query}' に関する情報: 関連ドキュメントが3件見つかりました。"
    return response.content[0].text


def summarize_subagent(client: anthropic.Anthropic, text: str) -> str:
    """要約専用サブエージェント: 純粋LLM処理のみ"""
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=256,
        system="あなたは要約専門エージェントです。与えられたテキストを3行以内で要約してください。",
        messages=[{"role": "user", "content": f"以下を要約してください:\n\n{text}"}]
    )
    return response.content[0].text


def decision_subagent(
    client: anthropic.Anthropic,
    summary: str,
    constraints: Dict[str, Any]
) -> str:
    """意思決定専用サブエージェント: 制約情報のみ保持"""
    constraint_text = "\n".join([f"- {k}: {v}" for k, v in constraints.items()])

    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=512,
        system=(
            "あなたは意思決定専門エージェントです。"
            "与えられた要約と制約条件に基づいて、最適な行動方針を提案してください。"
        ),
        messages=[{
            "role": "user",
            "content": (
                f"【要約情報】\n{summary}\n\n"
                f"【制約条件】\n{constraint_text}\n\n"
                "最適な行動方針を提案してください。"
            )
        }]
    )
    return response.content[0].text


def orchestrator_agent(task: str, constraints: Dict[str, Any]) -> Dict[str, str]:
    """
    オーケストレーター: 各サブエージェントに最小コンテキストのみ渡して協調させる
    """
    client = create_scoped_client()

    print("=== オーケストレーター開始 ===")

    print("[1/3] 検索サブエージェント実行中...")
    search_result = search_subagent(client, task)
    print(f"検索完了: {len(search_result)}文字")

    # Step 2: 要約サブエージェントには検索結果のみ渡す（他の情報は渡さない）
    print("[2/3] 要約サブエージェント実行中...")
    summary_result = summarize_subagent(client, search_result)
    print(f"要約完了: {len(summary_result)}文字")

    # Step 3: 意思決定サブエージェントには要約＋制約のみ渡す（生の検索結果は渡さない）
    print("[3/3] 意思決定サブエージェント実行中...")
    decision_result = decision_subagent(client, summary_result, constraints)
    print(f"意思決定完了: {len(decision_result)}文字")

    return {
        "search": search_result,
        "summary": summary_result,
        "decision": decision_result
    }


if __name__ == "__main__":
    task = "クラウドストレージサービスの比較"
    constraints = {
        "予算上限": "月額10万円",
        "必須要件": "99.9%以上のSLA",
        "除外条件": "中国系ベンダー"
    }

    results = orchestrator_agent(task, constraints)
    print("\n=== 最終意思決定 ===")
    print(results["decision"])

import json
from typing import Any
import anthropic

MAX_TOOL_CALLS = 5  # 最大ツール呼び出し回数（安全装置）


def make_tool_response(status: str, data: Any, message: str = "") -> str:
    """
    明確な終了シグナル付きツール応答を生成する
    status: "COMPLETE" | "PARTIAL" | "ERROR"
    """
    return json.dumps({
        "status": status,
        "data": data,
        "message": message,
        "instruction": (
            "status=COMPLETEの場合、これ以上のツール呼び出しは不要です。"
            if status == "COMPLETE"
            else "status=PARTIALの場合、必要であれば追加取得できます。"
        )
    }, ensure_ascii=False)


def simulate_database_tool(query: str, page: int = 1) -> str:
    """データベース検索ツール（終了シグナル付き）"""
    if page == 1:
        return make_tool_response(
            status="COMPLETE",
            data={
                "records": [
                    {"id": 1, "name": "Alice", "score": 95},
                    {"id": 2, "name": "Bob", "score": 87},
                    {"id": 3, "name": "Carol", "score": 92},
                ],
                "total": 3,
                "page": 1,
                "has_more": False
            },
            message="全3件のデータを取得しました。これ以上のデータはありません。"
        )
    else:
        return make_tool_response(
            status="COMPLETE",
            data={"records": [], "total": 0},
            message="追加データはありません。"
        )


def run_exit_signal_agent(user_query: str) -> str:
    """終了シグナル設計パターンを使ったエージェント"""
    client = anthropic.Anthropic()

    tools = [
        {
            "name": "search_database",
            "description": (
                "データベースを検索してレコードを返す。"
                "応答のstatusがCOMPLETEの場合は追加呼び出し不要。"
                "statusがPARTIALの場合のみ追加ページを取得すること。"
            ),
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "検索クエリ"},
                    "page": {
                        "type": "integer",
                        "description": "ページ番号（デフォルト: 1）",
                        "default": 1
                    }
                },
                "required": ["query"]
            }
        }
    ]

    messages = [{"role": "user", "content": user_query}]
    tool_call_count = 0

    print(f"エージェント開始: 最大{MAX_TOOL_CALLS}回のツール呼び出し制限あり")

    while tool_call_count < MAX_TOOL_CALLS:
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=1024,
            system=(
                "あなたはデータ検索エージェントです。"
                "ツール応答のstatusフィールドを必ず確認してください。"
                "status=COMPLETEの場合は即座に回答を生成し、ツールを再呼び出ししないでください。"
                "status=PARTIALの場合のみ、必要に応じて追加取得を検討してください。"
            ),
            tools=tools,
            messages=messages
        )

        if response.stop_reason != "tool_use":
            final_text = ""
            for block in response.content:
                if hasattr(block, "text"):
                    final_text = block.text
            print(f"完了: ツール呼び出し回数 = {tool_call_count}回")
            return final_text

        tool_call_count += 1
        print(f"ツール呼び出し #{tool_call_count}")

        messages.append({"role": "assistant", "content": response.content})

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                tool_input = block.input
                query = tool_input.get("query", "")
                page = tool_input.get("page", 1)

                result = simulate_database_tool(query, page)
                result_data = json.loads(result)
                print(f"  ツール応答 status: {result_data['status']}")

                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        messages.append({"role": "user", "content": tool_results})

    # 最大回数に達した場合の安全終了
    print(f"警告: 最大ツール呼び出し回数({MAX_TOOL_CALLS}回)に達しました。強制終了します。")
    safety_response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=256,
        system="これまでの情報をもとに、現時点での最善の回答を提供してください。",
        messages=messages
    )
    return safety_response.content[0].text


if __name__ == "__main__":
    result = run_exit_signal_agent("スコアが高い順にユーザー一覧を教えてください")
    print("\n=== 最終回答 ===")
    print(result)