Anthropic

Program Microsoft Agent Framework obsługuje tworzenie agentów korzystających z modeli Claude firmy Anthropic.

Wnioskowanie modelu bezpośredniego a zestaw SDK agenta Claude'a

obsługa Anthropic w programie Agent Framework ma dwie odrębne formy.

Integracja	Typ	Pętla agenta i narzędzia	Użyj, gdy
Wnioskowanie modelu bezpośredniego (ta strona)	`AnthropicClient` i warianty hostowane przez dostawcę, opakowane z `Agent(client=...)`	Aplikacja jest właścicielem pętli struktury agentów, sesji, oprogramowania pośredniczącego, narzędzi funkcji i obsługiwanych Anthropic narzędzi hostowanych.	Chcesz, aby Claude był modelem opartym na standardowym agencie platformy Agent Framework należącym do aplikacji.
zestaw SDK agenta Anthropic Claude	`ClaudeAgent`, skonstruowany bezpośrednio	Środowisko uruchomieniowe agenta kodowania Claude'a jest właścicielem sesji, uprawnień, wbudowanych narzędzi plików i powłoki oraz zachowania MCP.	Potrzebujesz zarządzanego środowiska uruchomieniowego i modelu uprawnień agenta kodowania Claude'a.

Wprowadzenie

Dodaj wymagane pakiety NuGet do projektu.

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

Jeśli używasz Microsoft Foundry, dodaj również następujące elementy:

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

Configuration

Zmienne środowiskowe

Skonfiguruj wymagane zmienne środowiskowe na potrzeby uwierzytelniania antropicznego:

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

Klucz API można uzyskać z konsoli Anthropic.

W przypadku Microsoft Foundry z kluczem interfejsu API

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

W przypadku Microsoft Foundry z Azure CLI

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

Note

W przypadku korzystania z Microsoft Foundry z Azure CLI upewnij się, że zalogowano az login się i masz dostęp do zasobu Foundry. Aby uzyskać więcej informacji, zobacz dokumentację Azure CLI.

Tworzenie agenta antropicznego

Tworzenie podstawowego agenta (antropiczny publiczny interfejs API)

Najprostszym sposobem utworzenia agenta antropicznego przy użyciu publicznego interfejsu API:

var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
var deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_CHAT_MODEL_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?"));

Korzystanie z Anthropic na platformie Foundry

Po skonfigurowaniu Anthropic w usłudze Microsoft Foundry można jej używać z uwierzytelnianiem klucza interfejsu API:

Uwierzytelnianie klucza interfejsu API

var resource = Environment.GetEnvironmentVariable("ANTHROPIC_RESOURCE");
var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");
var deploymentName = Environment.GetEnvironmentVariable("ANTHROPIC_CHAT_MODEL_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 Microsoft Foundry.");

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

Uwierzytelnianie poświadczeń Azure

W przypadku środowisk, w których preferowane są poświadczenia platformy Azure:

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

AnthropicClient client = new AnthropicFoundryClient(
    new AnthropicFoundryIdentityTokenCredentials(
        new DefaultAzureCredential(),
        resource,
        ["https://ai.azure.com/.default"]));

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

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

Warning

DefaultAzureCredential jest wygodne do programowania, ale wymaga starannego rozważenia w środowisku produkcyjnym. W środowisku produkcyjnym rozważ użycie określonego poświadczenia (np. ManagedIdentityCredential), aby uniknąć problemów z opóźnieniami, niezamierzonego sondowania poświadczeń i potencjalnych zagrożeń bezpieczeństwa wynikających z mechanizmów awaryjnych.

Wskazówka

Zobacz przykłady .NET dla kompletnych, działających przykładów.

Tools

Narzędzie	Status	Notatki
Narzędzia funkcji	✅	Wystąpienia Standard `AIFunction` za pomocą `AIFunctionFactory.Create(...)`.
Zatwierdzanie narzędzi	✅	Zapewniane przez klienta czatu wywołującego funkcje; działa z dowolnym wywołaniem narzędzia-funkcji.
Interpreter kodów	❌	Obecnie klient .NET Anthropic nie jest obsługiwany.
Wyszukiwanie plików	❌	Niewspierane.
Wyszukiwanie w Sieci Web	❌	Obecnie klient .NET Anthropic nie jest obsługiwany.
Hostowane narzędzia MCP	✅	Supported.
Lokalne narzędzia MCP	✅	Supported.

Myślenie rozszerzone

Skonfiguruj Anthropic wnioskowanie za pomocą nieprzetworzonej reprezentacji komunikatu i korzystaj TextReasoningContent z odpowiedzi regularnych lub przesyłanych strumieniowo.

var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY") ?? throw new InvalidOperationException("ANTHROPIC_API_KEY is not set.");
var model = Environment.GetEnvironmentVariable("ANTHROPIC_CHAT_MODEL_NAME") ?? "claude-haiku-4-5";
var maxTokens = 4096;
var thinkingTokens = 2048;

var agent = new AnthropicClient(new ClientOptions { ApiKey = apiKey })
    .AsAIAgent(
        model: model,
        clientFactory: (chatClient) => chatClient
            .AsBuilder()
            .ConfigureOptions(
                options => options.RawRepresentationFactory = (_) => new MessageCreateParams()
                {
                    Model = options.ModelId ?? model,
                    MaxTokens = options.MaxOutputTokens ?? maxTokens,
                    Messages = [],
                    Thinking = new ThinkingConfigParam(new ThinkingConfigEnabled(budgetTokens: thinkingTokens))
                })
            .Build());

Console.WriteLine("1. Non-streaming:");
var response = await agent.RunAsync("Solve this problem step by step: If a train travels 60 miles per hour and needs to cover 180 miles, how long will the journey take? Show your reasoning.");

Console.WriteLine("#### Start Thinking ####");
Console.WriteLine($"\e[92m{string.Join("\n", response.Messages.SelectMany(m => m.Contents.OfType<TextReasoningContent>().Select(c => c.Text)))}\e[0m");
Console.WriteLine("#### End Thinking ####");

Console.WriteLine("\n#### Final Answer ####");
Console.WriteLine(response.Text);

Console.WriteLine("Token usage:");
Console.WriteLine($"Input: {response.Usage?.InputTokenCount}, Output: {response.Usage?.OutputTokenCount}, {string.Join(", ", response.Usage?.AdditionalCounts ?? [])}");
Console.WriteLine();

Console.WriteLine("2. Streaming");
await foreach (var update in agent.RunStreamingAsync("Explain the theory of relativity in simple terms."))
{
    foreach (var item in update.Contents)
    {
        if (item is TextReasoningContent reasoningContent)
        {
            Console.WriteLine($"\e[92m{reasoningContent.Text}\e[0m");
        }
        else if (item is TextContent textContent)
        {
            Console.WriteLine(textContent.Text);
        }
    }
}

Umiejętności antropotyczne

Anthropic umiejętności zarządzane mogą tworzyć pliki za pośrednictwem hostowanego środowiska wykonywania kodu. Przykład zawiera listę dostępnych umiejętności, konfiguruje umiejętności PowerPoint i pobiera wygenerowany plik.

string apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY") ?? throw new InvalidOperationException("ANTHROPIC_API_KEY is not set.");
// Skills require Claude 4.5 models (Sonnet 4.5, Haiku 4.5, or Opus 4.5)
string model = Environment.GetEnvironmentVariable("ANTHROPIC_CHAT_MODEL_NAME") ?? "claude-sonnet-4-5-20250929";

// Create the Anthropic client
AnthropicClient anthropicClient = new() { ApiKey = apiKey };

// List available Anthropic-managed skills (optional - API may not be available in all regions)
Console.WriteLine("Available Anthropic-managed skills:");
try
{
    SkillListPage skills = await anthropicClient.Beta.Skills.List(
        new SkillListParams { Source = "anthropic", Betas = [AnthropicBeta.Skills2025_10_02] });

    foreach (var skill in skills.Items)
    {
        Console.WriteLine($"  {skill.Source}: {skill.ID} (version: {skill.LatestVersion})");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"  (Skills listing not available: {ex.Message})");
}

Console.WriteLine();

// Define the pptx skill - the SDK handles all beta flags and container configuration automatically
// when using AsAITool(), so no manual RawRepresentationFactory configuration is needed.
BetaSkillParams pptxSkill = new()
{
    Type = BetaSkillParamsType.Anthropic,
    SkillID = "pptx",
    Version = "latest"
};

// Create an agent with the pptx skill enabled.
// Skills require extended thinking and higher max tokens for complex file generation.
// The SDK's AsAITool() handles beta flags and container config automatically.
ChatClientAgent agent = anthropicClient.Beta.AsAIAgent(
    model: model,
    instructions: "You are a helpful agent for creating PowerPoint presentations.",
    tools: [pptxSkill.AsAITool()],
    clientFactory: (chatClient) => chatClient
        .AsBuilder()
        .ConfigureOptions(options =>
        {
            options.RawRepresentationFactory = (_) => new MessageCreateParams()
            {
                Model = model,
                MaxTokens = 20000,
                Messages = [],
                Thinking = new BetaThinkingConfigParam(
                    new BetaThinkingConfigEnabled(budgetTokens: 10000))
            };
        })
        .Build());

Console.WriteLine("Creating a presentation about renewable energy...\n");

// Run the agent with a request to create a presentation
AgentResponse response = await agent.RunAsync("Create a simple 3-slide presentation about renewable energy sources. Include a title slide, a slide about solar energy, and a slide about wind energy.");
// Collect generated files from CodeInterpreterToolResultContent outputs
List<HostedFileContent> hostedFiles = response.Messages
    .SelectMany(m => m.Contents.OfType<CodeInterpreterToolResultContent>())
    .Where(c => c.Outputs is not null)
    .SelectMany(c => c.Outputs!.OfType<HostedFileContent>())
    .ToList();

if (hostedFiles.Count > 0)
{
    Console.WriteLine("\n#### Generated Files ####");
    foreach (HostedFileContent file in hostedFiles)
    {
        Console.WriteLine($"  FileId: {file.FileId}");

        // Download the file using the Anthropic Files API
        using HttpResponse fileResponse = await anthropicClient.Beta.Files.Download(
            file.FileId,
            new FileDownloadParams { Betas = ["files-api-2025-04-14"] });

        // Save the file to disk
        string fileName = $"presentation_{file.FileId.Substring(0, 8)}.pptx";
        using FileStream fileStream = File.Create(fileName);
        Stream contentStream = await fileResponse.ReadAsStream();
        await contentStream.CopyToAsync(fileStream);

        Console.WriteLine($"  Saved to: {fileName}");

Korzystanie z agenta

Agent jest standardowy AIAgent i obsługuje wszystkie standardowe operacje agenta.

Aby uzyskać więcej informacji na temat uruchamiania agentów i interakcji z nimi, zobacz samouczki wprowadzające Agenta.

Wymagania wstępne

Zainstaluj pakiet antropiczny programu Microsoft Agent Framework.

pip install agent-framework-anthropic --pre

Configuration

Zmienne środowiskowe

Skonfiguruj wymagane zmienne środowiskowe na potrzeby uwierzytelniania antropicznego:

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

Alternatywnie możesz użyć pliku .env w katalogu głównym projektu.

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

Klucz API można uzyskać z konsoli Anthropic.

Wprowadzenie

Zaimportuj wymagane klasy z programu Agent Framework:

import asyncio
from agent_framework import Agent
from agent_framework.anthropic import AnthropicClient

Tworzenie agenta antropicznego

Tworzenie podstawowego agenta

Najprostszym sposobem utworzenia agenta antropicznego:

from agent_framework import Agent

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

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

Korzystanie z konfiguracji jawnej

Możesz podać jawną konfigurację zamiast polegać na zmiennych środowiskowych:

from agent_framework import Agent

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

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

Używanie niestandardowego podstawowego adresu URL

Przekaż base_url bezpośrednio do AnthropicClient, aby wskazać dowolny punkt końcowy zgodny z Anthropic, taki jak wdrożenie hostowane w usłudze Foundry. Pozwala to zachować ten sam AnthropicClient kod i zmienić tylko punkt końcowy, zamiast przełączać się na AnthropicFoundryClient:

from agent_framework import Agent

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

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

base_url wraca do zmiennej środowiskowej ANTHROPIC_BASE_URL , gdy nie przekazano jawnie.

Korzystanie z Anthropic na platformie Foundry

Po skonfigurowaniu platformy Anthropic w witrynie Foundry upewnij się, że ustawiono następujące zmienne środowiskowe:

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

Następnie utwórz agenta w następujący sposób:

from agent_framework import Agent
from agent_framework.anthropic import AnthropicFoundryClient

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

Note

Jeśli wolisz skonfigurować pełny punkt końcowy zgodny z Anthropic zamiast nazwy zasobu, ustaw ANTHROPIC_FOUNDRY_BASE_URL oprócz elementu ANTHROPIC_FOUNDRY_API_KEY.

Korzystanie z Anthropic w usłudze Amazon Bedrock

AnthropicBedrockClient route Claude model wnioskowanie przez Amazon Bedrock.

AWS_ACCESS_KEY_ID="<access-key>"
AWS_SECRET_ACCESS_KEY="<secret-key>"
AWS_REGION="us-east-1"
# Optional:
AWS_PROFILE="<profile>"
AWS_SESSION_TOKEN="<session-token>"
ANTHROPIC_BEDROCK_BASE_URL="<custom-endpoint>"
ANTHROPIC_CHAT_MODEL="anthropic.claude-3-5-sonnet-20241022-v2:0"

Obecnie nie opublikowano przykładu platformy Agent Framework możliwego do uruchomienia dla programu AnthropicBedrockClient.

Korzystanie z Anthropic w usłudze Google Vertex AI

AnthropicVertexClient routes Claude model wnioskowanie za pośrednictwem Google Vertex AI.

CLOUD_ML_REGION="us-east5"
ANTHROPIC_VERTEX_PROJECT_ID="<google-cloud-project>"
ANTHROPIC_CHAT_MODEL="claude-sonnet-4@20250514"
# Optional:
ANTHROPIC_VERTEX_BASE_URL="<custom-endpoint>"

Obecnie nie opublikowano przykładu platformy Agent Framework możliwego do uruchomienia dla programu AnthropicVertexClient.

Tools

AnthropicClient udostępnia fabryki narzędzi hostowane przez Anthropic obok standardowej obsługi narzędzi funkcyjnych. Użyj client.get_*_tool(...) polecenia , aby skompilować narzędzie i przekazać je za pomocą tools= polecenia Agent(...).

Narzędzie	Fabryka/budowa	Status	Notatki
Narzędzia funkcji	Przekaż dowolny obiekt wywoływalny w Pythonie lub `@ai_function`	✅	Wywoływane lokalnie w procesie Python.
Zatwierdzanie narzędzi	Obsługiwany przez klienta czatu frameworka wywołującego funkcje	✅	Działa z dowolnym wywołaniem funkcji lub narzędzia.
Interpreter kodów	`client.get_code_interpreter_tool()`	✅	Wymagane dla Umiejętności Anthropic.
Wyszukiwanie plików	n/a	❌	Nie jest udostępniane przez interfejs API Anthropic.
Wyszukiwanie w Sieci Web	`client.get_web_search_tool()`	✅	Wyszukiwanie internetowe hostowane przez Anthropic.
Hostowane narzędzia MCP	`client.get_mcp_tool(name=..., url=...)`	✅	Zdalne serwery MCP wywoływane przez Anthropic.
Lokalne narzędzia MCP	`MCPStreamableHTTPTool` / `MCPStdioTool`	✅	Działa w Twoim procesie.

Aby zobaczyć bogatsze przykłady — łączące hostowanego MCP, wyszukiwanie w Internecie, rozszerzone myślenie i funkcje Anthropic Skills — zobacz poniżej Hosted Tools.

Funkcje agenta

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

from agent_framework import Agent

async def tools_example():
    agent = Agent(
        client=AnthropicClient(),
        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)

Odpowiedzi w strumieniowaniu

Uzyskuj odpowiedzi w miarę ich generowania w celu lepszego doświadczenia użytkownika.

from agent_framework import Agent

async def streaming_example():
    agent = Agent(
        client=AnthropicClient(),
        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()

Narzędzia hostowane

Agenciropijni obsługują hostowane narzędzia, takie jak wyszukiwanie w Internecie, protokół MCP (protokół kontekstu modelu) i wykonywanie kodu:

from agent_framework import Agent
from agent_framework.anthropic import AnthropicClient

async def hosted_tools_example():
    client = AnthropicClient()
    agent = Agent(
        client=client,
        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(),
        ],
        default_options={"max_tokens": 20000},
    )

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

Rozszerzone Myślenie (Rozumowanie)

Anthropic wspiera rozszerzone możliwości myślenia za pomocą thinking funkcji, która umożliwia modelowi pokazanie jego procesu rozumowania.

from agent_framework import Agent
from agent_framework.anthropic import AnthropicClient

async def thinking_example():
    client = AnthropicClient()
    agent = Agent(
        client=client,
        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 content.type == "text_reasoning":
                # Display thinking in a different color
                print(f"\033[32m{content.text}\033[0m", end="", flush=True)
            if content.type == "usage":
                print(f"\n\033[34m[Usage: {content.usage_details}]\033[0m\n", end="", flush=True)
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print()

Umiejętności antropotyczne

Anthropic zapewnia zarządzane umiejętności, które rozszerzają możliwości agenta, takie jak tworzenie prezentacji programu PowerPoint. Umiejętności wymagają, aby narzędzie Interpreter kodu działało:

from agent_framework import Agent, Content
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 = Agent(
        client=client,
        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[Content] = []
    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.")

Kompletny przykład

# Copyright (c) Microsoft. All rights reserved.

import asyncio
from random import randint
from typing import Annotated

from agent_framework import Agent, 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 = Agent(
        client=AnthropicClient(),
        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 = Agent(
        client=AnthropicClient(),
        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())

Korzystanie z agenta

Agent jest standardowy Agent i obsługuje wszystkie standardowe operacje agenta.

Aby uzyskać więcej informacji na temat uruchamiania agentów i interakcji z nimi, zobacz samouczki wprowadzające Agenta.

Anthropic

Pakiet anthropicprovider tworzy agentów przy użyciu interfejsu API Anthropic.

Instalacja

go get github.com/microsoft/agent-framework-go

Utwórz agenta Anthropic

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/anthropicprovider"

    "github.com/anthropics/anthropic-sdk-go"
)

a := anthropicprovider.NewAgent(
    anthropic.NewClient(), // uses ANTHROPIC_API_KEY env var
    anthropicprovider.AgentConfig{
        Model: "claude-sonnet-4-5",
        Instructions: "You are a helpful assistant.",
        Config: agent.Config{
            Name:         "ClaudeAgent",
        },
    },
)

resp, err := a.RunText(ctx, "Tell me a joke.").Collect()

Opcje niestandardowe

Przekaż parametry specyficzne dla Anthropic przy użyciu polecenia anthropicprovider.MessageNewParams:

resp, err := a.RunText(ctx, "Hello!",
    anthropicprovider.MessageNewParams(anthropic.MessageNewParams{
        MaxTokens: 500,
    }),
).Collect()

Wskazówka

Zobacz przykład Anthropic, aby zapoznać się z kompletnym przykładem.

Następne kroki

Ollama

Opinia

Czy ta strona była pomocna?

Last updated on 2026-08-13

Anthropic

Wnioskowanie modelu bezpośredniego a zestaw SDK agenta Claude'a

Wprowadzenie

Configuration

Zmienne środowiskowe

W przypadku Microsoft Foundry z kluczem interfejsu API

W przypadku Microsoft Foundry z Azure CLI

Tworzenie agenta antropicznego

Tworzenie podstawowego agenta (antropiczny publiczny interfejs API)

Korzystanie z Anthropic na platformie Foundry

Uwierzytelnianie klucza interfejsu API

Uwierzytelnianie poświadczeń Azure

Tools

Myślenie rozszerzone

Umiejętności antropotyczne

Korzystanie z agenta

Wymagania wstępne

Configuration

Zmienne środowiskowe

Wprowadzenie

Tworzenie agenta antropicznego

Tworzenie podstawowego agenta

Korzystanie z konfiguracji jawnej

Używanie niestandardowego podstawowego adresu URL

Korzystanie z Anthropic na platformie Foundry

Korzystanie z Anthropic w usłudze Amazon Bedrock

Korzystanie z Anthropic w usłudze Google Vertex AI

Tools

Funkcje agenta

Odpowiedzi w strumieniowaniu

Narzędzia hostowane

Rozszerzone Myślenie (Rozumowanie)

Umiejętności antropotyczne

Kompletny przykład

Korzystanie z agenta

Anthropic

Instalacja

Utwórz agenta Anthropic

Opcje niestandardowe

Następne kroki

Opinia

Dodatkowe zasoby