Antropičtí agenti

Rozhraní Microsoft Agent Framework podporuje vytváření agentů, kteří používají modely Clauda Anthropic.

Začínáme

Přidejte do projektu požadované balíčky NuGet.

dotnet add package Microsoft.Agents.AI.Anthropic --prerelease

Pokud používáte Azure Foundry, přidejte také:

dotnet add package Anthropic.Foundry --prerelease
dotnet add package Azure.Identity

Konfigurace

Proměnné prostředí

Nastavte požadované proměnné prostředí pro ověřování Anthropic:

# Required for Anthropic API access
$env:ANTHROPIC_API_KEY="your-anthropic-api-key"
$env:ANTHROPIC_DEPLOYMENT_NAME="claude-haiku-4-5"  # or your preferred model

Klíč rozhraní API můžete získat z konzoly Anthropic.

Pro Azure Foundry s API klíčem

$env:ANTHROPIC_RESOURCE="your-foundry-resource-name"  # Subdomain before .services.ai.azure.com
$env:ANTHROPIC_API_KEY="your-anthropic-api-key"
$env:ANTHROPIC_DEPLOYMENT_NAME="claude-haiku-4-5"

Azure Foundry s využitím Azure CLI

$env:ANTHROPIC_RESOURCE="your-foundry-resource-name"  # Subdomain before .services.ai.azure.com
$env:ANTHROPIC_DEPLOYMENT_NAME="claude-haiku-4-5"

Poznámka:

Pokud používáte Azure Foundry s Azure CLI, ujistěte se, že jste přihlášeni az login a máte přístup k prostředku Azure Foundry. Další informace najdete v dokumentaci k Azure CLI.

Vytvoření agenta Anthropic

Vytvoření základního agenta (veřejné rozhraní API antropic)

Nejjednodušší způsob, jak vytvořit agenta Anthropic pomocí veřejného rozhraní API:

var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
var deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_DEPLOYMENT_NAME") ?? "claude-haiku-4-5";

AnthropicClient client = new() { APIKey = apiKey };

AIAgent agent = client.AsAIAgent(
    model: deploymentName,
    name: "HelpfulAssistant",
    instructions: "You are a helpful assistant.");

// Invoke the agent and output the text result.
Console.WriteLine(await agent.RunAsync("Hello, how can you help me?"));

Použití Anthropicu v Azure Foundry s klíčem rozhraní API

Po nastavení Anthropic v Azure Foundry ho můžete použít s ověřováním pomocí klíče rozhraní API:

var resource = Environment.GetEnvironmentVariable("ANTHROPIC_RESOURCE");
var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
var deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_DEPLOYMENT_NAME") ?? "claude-haiku-4-5";

AnthropicClient client = new AnthropicFoundryClient(
    new AnthropicFoundryApiKeyCredentials(apiKey, resource));

AIAgent agent = client.AsAIAgent(
    model: deploymentName,
    name: "FoundryAgent",
    instructions: "You are a helpful assistant using Anthropic on Azure Foundry.");

Console.WriteLine(await agent.RunAsync("How do I use Anthropic on Foundry?"));

Použití anthropicu v Azure Foundry s přihlašovacími údaji Azure (příklad přihlašovacích údajů Azure Cli)

Pro prostředí, kde se preferují přihlašovací údaje Azure:

var resource = Environment.GetEnvironmentVariable("ANTHROPIC_RESOURCE");
var deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_DEPLOYMENT_NAME") ?? "claude-haiku-4-5";

AnthropicClient client = new AnthropicFoundryClient(
    new AnthropicAzureTokenCredential(new DefaultAzureCredential(), resource));

AIAgent agent = client.AsAIAgent(
    model: deploymentName,
    name: "FoundryAgent",
    instructions: "You are a helpful assistant using Anthropic on Azure Foundry.");

Console.WriteLine(await agent.RunAsync("How do I use Anthropic on Foundry?"));

/// <summary>
/// Provides methods for invoking the Azure hosted Anthropic models using <see cref="TokenCredential"/> types.
/// </summary>
public sealed class AnthropicAzureTokenCredential(TokenCredential tokenCredential, string resourceName) : IAnthropicFoundryCredentials
{
    /// <inheritdoc/>
    public string ResourceName { get; } = resourceName;

    /// <inheritdoc/>
    public void Apply(HttpRequestMessage requestMessage)
    {
        requestMessage.Headers.Authorization = new AuthenticationHeaderValue(
                scheme: "bearer",
                parameter: tokenCredential.GetToken(new TokenRequestContext(scopes: ["https://ai.azure.com/.default"]), CancellationToken.None)
                    .Token);
    }
}

Výstraha

DefaultAzureCredential je vhodný pro vývoj, ale vyžaduje pečlivé zvážení v produkčním prostředí. V produkčním prostředí zvažte použití konkrétních přihlašovacích údajů (např ManagedIdentityCredential. ) k zabránění problémům s latencí, neúmyslnému testování přihlašovacích údajů a potenciálním bezpečnostním rizikům z náhradních mechanismů.

Návod

Najdete kompletní spustitelné příklady v ukázkách .NET.

Použití agenta

Agent je standardní AIAgent a podporuje všechny standardní operace agentů.

Další informace o spouštění a interakci s agenty najdete v kurzech Začínáme s agenty .

Požadavky

Nainstalujte balíček Anthropic Microsoft Agent Framework.

pip install agent-framework-anthropic --pre

Konfigurace

Proměnné prostředí

Nastavte požadované proměnné prostředí pro ověřování Anthropic:

# Required for Anthropic API access
ANTHROPIC_API_KEY="your-anthropic-api-key"
ANTHROPIC_CHAT_MODEL_ID="claude-sonnet-4-5-20250929"  # or your preferred model

Případně můžete použít .env soubor v kořenovém adresáři projektu:

ANTHROPIC_API_KEY=your-anthropic-api-key
ANTHROPIC_CHAT_MODEL_ID=claude-sonnet-4-5-20250929

Klíč rozhraní API můžete získat z konzoly Anthropic.

Začínáme

Importujte požadované třídy z rozhraní Agent Framework:

import asyncio
from agent_framework.anthropic import AnthropicClient

Vytvoření agenta Anthropic

Základní vytvoření agenta

Nejjednodušší způsob, jak vytvořit agenta Anthropic:

async def basic_example():
    # Create an agent using Anthropic
    agent = AnthropicClient().as_agent(
        name="HelpfulAssistant",
        instructions="You are a helpful assistant.",
    )

    result = await agent.run("Hello, how can you help me?")
    print(result.text)

Použití explicitní konfigurace

Explicitní konfiguraci můžete zadat místo toho, abyste se spoléhali na proměnné prostředí:

async def explicit_config_example():
    agent = AnthropicClient(
        model_id="claude-sonnet-4-5-20250929",
        api_key="your-api-key-here",
    ).as_agent(
        name="HelpfulAssistant",
        instructions="You are a helpful assistant.",
    )

    result = await agent.run("What can you do?")
    print(result.text)

Použití Anthropic v Foundry

Po nastavení Anthropic v Foundry se ujistěte, že máte nastavené následující proměnné prostředí:

ANTHROPIC_FOUNDRY_API_KEY="your-foundry-api-key"
ANTHROPIC_FOUNDRY_RESOURCE="your-foundry-resource-name"

Pak vytvořte agenta následujícím způsobem:

from agent_framework.anthropic import AnthropicClient
from anthropic import AsyncAnthropicFoundry

async def foundry_example():
    agent = AnthropicClient(
        anthropic_client=AsyncAnthropicFoundry()
    ).as_agent(
        name="FoundryAgent",
        instructions="You are a helpful assistant using Anthropic on Foundry.",
    )

    result = await agent.run("How do I use Anthropic on Foundry?")
    print(result.text)

Poznámka: To vyžaduje anthropic>=0.74.0 instalaci.

Funkce agenta

Funkční nástroje

Vybavení agenta vlastními funkcemi:

from typing import Annotated

def get_weather(
    location: Annotated[str, "The location to get the weather for."],
) -> str:
    """Get the weather for a given location."""
    conditions = ["sunny", "cloudy", "rainy", "stormy"]
    return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."

async def tools_example():
    agent = AnthropicClient().as_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather assistant.",
        tools=get_weather,  # Add tools to the agent
    )

    result = await agent.run("What's the weather like in Seattle?")
    print(result.text)

Odpovědi na streamování

Získejte odpovědi, protože se generují pro lepší uživatelské prostředí:

async def streaming_example():
    agent = AnthropicClient().as_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather agent.",
        tools=get_weather,
    )

    query = "What's the weather like in Portland and in Paris?"
    print(f"User: {query}")
    print("Agent: ", end="", flush=True)
    async for chunk in agent.run(query, stream=True):
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print()

Hostované nástroje

Agenti Anthropic podporují hostované nástroje, jako je vyhledávání na webu, MCP (Model Context Protocol) a spouštění kódu:

from agent_framework.anthropic import AnthropicClient

async def hosted_tools_example():
    client = AnthropicClient()
    agent = client.as_agent(
        name="DocsAgent",
        instructions="You are a helpful agent for both Microsoft docs questions and general questions.",
        tools=[
            client.get_mcp_tool(
                name="Microsoft Learn MCP",
                url="https://learn.microsoft.com/api/mcp",
            ),
            client.get_web_search_tool(),
        ],
        max_tokens=20000,
    )

    result = await agent.run("Can you compare Python decorators with C# attributes?")
    print(result.text)

Rozšířené myšlení (odůvodnění)

Anthropic podporuje rozšířené možnosti myšlení díky funkci thinking, která modelu umožňuje zobrazit jeho proces uvažování.

from agent_framework import TextReasoningContent, UsageContent
from agent_framework.anthropic import AnthropicClient

async def thinking_example():
    client = AnthropicClient()
    agent = client.as_agent(
        name="DocsAgent",
        instructions="You are a helpful agent.",
        tools=[client.get_web_search_tool()],
        default_options={
            "max_tokens": 20000,
            "thinking": {"type": "enabled", "budget_tokens": 10000}
        },
    )

    query = "Can you compare Python decorators with C# attributes?"
    print(f"User: {query}")
    print("Agent: ", end="", flush=True)

    async for chunk in agent.run(query, stream=True):
        for content in chunk.contents:
            if isinstance(content, TextReasoningContent):
                # Display thinking in a different color
                print(f"\033[32m{content.text}\033[0m", end="", flush=True)
            if isinstance(content, UsageContent):
                print(f"\n\033[34m[Usage: {content.details}]\033[0m\n", end="", flush=True)
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print()

Dovednosti Anthropic

Anthropic poskytuje spravované dovednosti, které rozšiřují možnosti agenta, jako je vytváření powerpointových prezentací. Dovednosti vyžadují, aby nástroj Interpret kódu fungoval:

from agent_framework import HostedFileContent
from agent_framework.anthropic import AnthropicClient

async def skills_example():
    # Create client with skills beta flag
    client = AnthropicClient(additional_beta_flags=["skills-2025-10-02"])

    # Create an agent with the pptx skill enabled
    # Skills require the Code Interpreter tool
    agent = client.as_agent(
        name="PresentationAgent",
        instructions="You are a helpful agent for creating PowerPoint presentations.",
        tools=client.get_code_interpreter_tool(),
        default_options={
            "max_tokens": 20000,
            "thinking": {"type": "enabled", "budget_tokens": 10000},
            "container": {
                "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
            },
        },
    )

    query = "Create a presentation about renewable energy with 5 slides"
    print(f"User: {query}")
    print("Agent: ", end="", flush=True)

    files: list[HostedFileContent] = []
    async for chunk in agent.run(query, stream=True):
        for content in chunk.contents:
            match content.type:
                case "text":
                    print(content.text, end="", flush=True)
                case "text_reasoning":
                    print(f"\033[32m{content.text}\033[0m", end="", flush=True)
                case "hosted_file":
                    # Catch generated files
                    files.append(content)

    print("\n")

    # Download generated files
    if files:
        print("Generated files:")
        for idx, file in enumerate(files):
            file_content = await client.anthropic_client.beta.files.download(
                file_id=file.file_id,
                betas=["files-api-2025-04-14"]
            )
            filename = f"presentation-{idx}.pptx"
            with open(filename, "wb") as f:
                await file_content.write_to_file(f.name)
            print(f"File {idx}: {filename} saved to disk.")

Kompletní příklad

# Copyright (c) Microsoft. All rights reserved.

import asyncio
from random import randint
from typing import Annotated

from agent_framework import tool
from agent_framework.anthropic import AnthropicClient

"""
Anthropic Chat Agent Example

This sample demonstrates using Anthropic with an agent and a single custom tool.
"""


# NOTE: approval_mode="never_require" is for sample brevity. Use "always_require" in production; see samples/02-agents/tools/function_tool_with_approval.py and samples/02-agents/tools/function_tool_with_approval_and_sessions.py.
@tool(approval_mode="never_require")
def get_weather(
    location: Annotated[str, "The location to get the weather for."],
) -> str:
    """Get the weather for a given location."""
    conditions = ["sunny", "cloudy", "rainy", "stormy"]
    return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."


async def non_streaming_example() -> None:
    """Example of non-streaming response (get the complete result at once)."""
    print("=== Non-streaming Response Example ===")

    agent = AnthropicClient(
    ).as_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather agent.",
        tools=get_weather,
    )

    query = "What's the weather like in Seattle?"
    print(f"User: {query}")
    result = await agent.run(query)
    print(f"Result: {result}\n")


async def streaming_example() -> None:
    """Example of streaming response (get results as they are generated)."""
    print("=== Streaming Response Example ===")

    agent = AnthropicClient(
    ).as_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather agent.",
        tools=get_weather,
    )

    query = "What's the weather like in Portland and in Paris?"
    print(f"User: {query}")
    print("Agent: ", end="", flush=True)
    async for chunk in agent.run(query, stream=True):
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print("\n")


async def main() -> None:
    print("=== Anthropic Example ===")

    await streaming_example()
    await non_streaming_example()


if __name__ == "__main__":
    asyncio.run(main())

Použití agenta

Agent je standardní Agent a podporuje všechny standardní operace agentů.

Další informace o spouštění a interakci s agenty najdete v kurzech Začínáme s agenty .

Další kroky

Agenti Azure AI

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-02-13

Sdílet prostřednictvím

Antropičtí agenti

Začínáme

Konfigurace

Proměnné prostředí

Pro Azure Foundry s API klíčem

Azure Foundry s využitím Azure CLI

Vytvoření agenta Anthropic

Vytvoření základního agenta (veřejné rozhraní API antropic)

Použití Anthropicu v Azure Foundry s klíčem rozhraní API

Použití anthropicu v Azure Foundry s přihlašovacími údaji Azure (příklad přihlašovacích údajů Azure Cli)

Použití agenta

Požadavky

Konfigurace

Proměnné prostředí

Začínáme

Vytvoření agenta Anthropic

Základní vytvoření agenta

Použití explicitní konfigurace

Použití Anthropic v Foundry

Funkce agenta

Funkční nástroje

Odpovědi na streamování

Hostované nástroje

Rozšířené myšlení (odůvodnění)

Dovednosti Anthropic

Kompletní příklad

Použití agenta

Další kroky

Váš názor

Další materiály