Antropische agenten

Het Microsoft Agent Framework biedt ondersteuning voor het maken van agents die gebruikmaken van de Claude-modellen van Antropic.

Aan de slag komen

Voeg de vereiste NuGet-pakketten toe aan uw project.

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

Als u Azure Foundry gebruikt, voegt u ook het volgende toe:

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

Configuratie

Omgevingsvariabelen

Stel de vereiste omgevingsvariabelen in voor antropische verificatie:

# 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

U kunt een API-sleutel ophalen uit de Tropic Console.

Voor door de provider gehoste Antropische eindpunten toont het Python-pakket ook AnthropicFoundryClient, AnthropicBedrockClient, en AnthropicVertexClient.

Voor Azure Foundry met API-sleutel

$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"

Voor Azure Foundry met Azure CLI

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

Opmerking

Wanneer u Azure Foundry gebruikt met Azure CLI, moet u ervoor zorgen dat u bent aangemeld met az login en toegang hebt tot de Azure Foundry-resource. Zie de Documentatie van Azure CLI voor meer informatie.

Een antropische agent maken

Basic Agent Creation (Antropic Public API)

De eenvoudigste manier om een Antropische agent te maken met behulp van de openbare 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?"));

Antropic gebruiken in Azure Foundry met API-sleutel

Nadat u Antropic hebt ingesteld in Azure Foundry, kunt u deze gebruiken met API-sleutelverificatie:

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?"));

Antropic gebruiken in Azure Foundry met Azure Credentials (Azure Cli Credential example)

Voor omgevingen waar Azure-referenties de voorkeur hebben:

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);
    }
}

Waarschuwing

DefaultAzureCredential is handig voor ontwikkeling, maar vereist zorgvuldige overwegingen in de productieomgeving. Overweeg in productie een specifieke referentie te gebruiken (bijvoorbeeld ManagedIdentityCredential) om latentieproblemen, onbedoelde referentieprobing en potentiële beveiligingsrisico's van terugvalmechanismen te voorkomen.

Aanbeveling

Zie de .NET-voorbeelden voor volledige runnable voorbeelden.

Tools

Tool	Status	Aantekeningen
Functiehulpmiddelen	✅	Standaardinstanties AIFunction via AIFunctionFactory.Create(...).
Goedkeuring van hulpprogramma	✅	Geleverd door de chatclient die functies aanroept; werkt met elke functie-toolaanroep.
Code-interpreter	❌	Wordt momenteel niet ondersteund door de .NET Anthropic-client.
Zoeken naar bestanden	❌	Wordt niet ondersteund.
Zoeken op internet	❌	Wordt momenteel niet ondersteund door de .NET Anthropic-client.
Gehoste MCP-tools	✅	Supported.
Lokale MCP-hulpprogramma's	✅	Supported.

De agent gebruiken

De agent is een standaard AIAgent en ondersteunt alle standaardagentbewerkingen.

Zie de Aan de slag met agent-zelfstudies voor meer informatie over het uitvoeren en interactie met agents.

Vereiste voorwaarden

Installeer het Microsoft Agent Framework Antropic-pakket.

pip install agent-framework-anthropic --pre

Configuratie

Omgevingsvariabelen

Stel de vereiste omgevingsvariabelen in voor antropische verificatie:

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

# Optional: override the Anthropic API endpoint (e.g. for Foundry-compatible deployments)
ANTHROPIC_BASE_URL="https://your-custom-endpoint.com"

U kunt ook een .env bestand gebruiken in de hoofdmap van uw project:

ANTHROPIC_API_KEY=your-anthropic-api-key
ANTHROPIC_CHAT_MODEL=claude-sonnet-4-5-20250929
# ANTHROPIC_BASE_URL=https://your-custom-endpoint.com  # optional

U kunt een API-sleutel ophalen uit de Tropic Console.

Aan de slag komen

Importeer de vereiste klassen uit het Agent Framework:

import asyncio
from agent_framework.anthropic import AnthropicClient

Een antropische agent maken

Basisagent maken

De eenvoudigste manier om een Antropische agent te maken:

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)

Expliciete configuratie gebruiken

U kunt expliciete configuratie opgeven in plaats van te vertrouwen op omgevingsvariabelen:

async def explicit_config_example():
    agent = AnthropicClient(
        model="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)

Een aangepaste basis-URL gebruiken

Geef base_url rechtstreeks door aan AnthropicClient om deze te laten verwijzen naar een Anthropic-compatibel eindpunt, zoals een door Foundry gehoste implementatie. Hiermee kunt u dezelfde AnthropicClient code behouden en alleen het eindpunt wijzigen in plaats van over te schakelen naar AnthropicFoundryClient:

async def custom_base_url_example():
    agent = AnthropicClient(
        model="claude-haiku-4-5",
        api_key="your-api-key-here",
        base_url="https://your-foundry-resource.services.ai.azure.com/models/anthropic",
    ).as_agent(
        name="HelpfulAssistant",
        instructions="You are a helpful assistant.",
    )

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

base_url valt terug naar de ANTHROPIC_BASE_URL omgevingsvariabele wanneer deze niet expliciet wordt doorgegeven.

Antropisch gebruiken in Foundry

Nadat u Lantropic hebt ingesteld voor Foundry, controleert u of de volgende omgevingsvariabelen zijn ingesteld:

ANTHROPIC_FOUNDRY_API_KEY="your-foundry-api-key"
ANTHROPIC_FOUNDRY_RESOURCE="your-foundry-resource-name"
ANTHROPIC_CHAT_MODEL="claude-haiku-4-5"

Maak vervolgens de agent als volgt:

from agent_framework.foundry import AnthropicFoundryClient

async def foundry_example():
    agent = AnthropicFoundryClient().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)

Opmerking

Als u liever een volledig Anthropic-compatibel eindpunt configureert in plaats van een resourcenaam, stelt u ANTHROPIC_FOUNDRY_BASE_URL in, naast ANTHROPIC_FOUNDRY_API_KEY.

Tools

AnthropicClient maakt gehoste Anthropic tool factory's beschikbaar naast de standaard functiehulpmiddelondersteuning. Gebruik client.get_*_tool(...) om een hulpprogramma te bouwen en het via tools= door te geven op as_agent(...) of Agent(...).

Tool	Fabriek/ bouw	Status	Aantekeningen
Functiehulpmiddelen	Geef een Python-callable of @ai_function door	✅	Lokaal aangeroepen in uw Python proces.
Goedkeuring van hulpprogramma	Afgehandeld door de chatclient van het framework voor functieaanroepen	✅	Werkt met elke aanroep van een functiehulpmiddel.
Code-interpreter	client.get_code_interpreter_tool()	✅	Vereist voor Anthropic Skills.
Zoeken naar bestanden	n.v.t.	❌	Niet beschikbaar gesteld door de Anthropic-API.
Zoeken op internet	client.get_web_search_tool()	✅	Gehoste webzoekfunctie van Anthropic.
Gehoste MCP-tools	client.get_mcp_tool(name=..., url=...)	✅	Externe MCP-servers die door Anthropic worden aangeroepen.
Lokale MCP-hulpprogramma's	MCPStreamableHTTPTool / MCPStdioTool	✅	Wordt uitgevoerd in uw proces.

Zie hieronder Hosted Tools voor uitgebreidere voorbeelden waarin gehoste MCP, webzoekopdrachten, uitgebreid nadenken en Anthropic Skills worden gecombineerd.

Agent functies

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)

Streamingreacties

Antwoorden ophalen wanneer ze worden gegenereerd voor een betere gebruikerservaring:

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()

Gehoste hulpprogramma's

Antropische agents ondersteunen gehoste hulpprogramma's zoals webzoekopdrachten, MCP (Model Context Protocol) en uitvoering van code:

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)

Uitgebreid denken (redeneren)

Lantropic biedt ondersteuning voor uitgebreide denkmogelijkheden via de thinking functie, waardoor het model het redeneringsproces kan weergeven:

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()

Antropische vaardigheden

Antropic biedt beheerde vaardigheden waarmee agentmogelijkheden worden uitgebreid, zoals het maken van PowerPoint-presentaties. Voor vaardigheden is het hulpprogramma Code-interpreter vereist om te kunnen functioneren:

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.")

Volledig voorbeeld

# 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())

De agent gebruiken

De agent is een standaard Agent en ondersteunt alle standaardagentbewerkingen.

Zie de Aan de slag met agent-zelfstudies voor meer informatie over het uitvoeren en interactie met agents.

Volgende stappen

Ollama