Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Das Microsoft Agent Framework unterstützt das Erstellen von Agents, die die Claude-Modelle von Anthropic verwenden.
Erste Schritte
Fügen Sie dem Projekt die erforderlichen NuGet-Pakete hinzu.
dotnet add package Microsoft.Agents.AI.Anthropic --prerelease
Wenn Sie Azure Foundry verwenden, fügen Sie außerdem Folgendes hinzu:
dotnet add package Anthropic.Foundry --prerelease
dotnet add package Azure.Identity
Konfiguration
Umgebungsvariablen
Richten Sie die erforderlichen Umgebungsvariablen für die anthropische Authentifizierung ein:
# 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
Sie können einen API-Schlüssel über die Anthropic-Konsole abrufen.
Für Azure Foundry mit API-Schlüssel
$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"
Für Azure Foundry mit Azure CLI
$env:ANTHROPIC_RESOURCE="your-foundry-resource-name" # Subdomain before .services.ai.azure.com
$env:ANTHROPIC_DEPLOYMENT_NAME="claude-haiku-4-5"
Hinweis
Wenn Sie Azure Foundry mit Azure CLI verwenden, stellen Sie sicher, dass Sie angemeldet az login sind und Zugriff auf die Azure Foundry-Ressource haben. Weitere Informationen finden Sie in der Azure CLI-Dokumentation.
Erstellen eines anthropischen Agents
Grundlagen der Agentenentwicklung (Anthropic Public API)
Die einfachste Möglichkeit zum Erstellen eines anthropischen Agents mithilfe der öffentlichen 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?"));
Verwenden von Anthropic auf Azure Foundry mit API-Schlüssel
Nachdem Sie Anthropic in Azure Foundry eingerichtet haben, können Sie sie mit API-Schlüsselauthentifizierung verwenden:
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?"));
Verwenden von Anthropic in Azure Foundry mit Azure-Anmeldeinformationen (Beispiel für Azure Cli-Anmeldeinformationen)
Für Umgebungen, in denen Azure-Anmeldeinformationen bevorzugt werden:
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);
}
}
Warnung
DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.
Tipp
Vollständige Runnable-Beispiele finden Sie in den .NET-Beispielen .
Den Agent verwenden
Der Agent ist ein Standard AIAgent und unterstützt alle Standard-Agent-Vorgänge.
Weitere Informationen zum Ausführen und Interagieren mit Agenten finden Sie in den Einführung in Agenten Tutorials.
Voraussetzungen
Installieren Sie das Anthropic-Paket von Microsoft Agent Framework.
pip install agent-framework-anthropic --pre
Konfiguration
Umgebungsvariablen
Richten Sie die erforderlichen Umgebungsvariablen für die anthropische Authentifizierung ein:
# 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
Alternativ können Sie eine .env Datei im Projektstamm verwenden:
ANTHROPIC_API_KEY=your-anthropic-api-key
ANTHROPIC_CHAT_MODEL_ID=claude-sonnet-4-5-20250929
Sie können einen API-Schlüssel über die Anthropic-Konsole abrufen.
Erste Schritte
Importieren Sie die erforderlichen Klassen aus dem Agent Framework:
import asyncio
from agent_framework.anthropic import AnthropicClient
Erstellen eines anthropischen Agents
Grundlegende Agent-Erstellung
Die einfachste Möglichkeit zum Erstellen eines anthropischen Agents:
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)
Verwendung der expliziten Konfiguration
Sie können eine explizite Konfiguration bereitstellen, anstatt sich auf Umgebungsvariablen zu verlassen:
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)
Verwenden von Anthropic on Foundry
Nachdem Sie "Anthropic on Foundry" eingerichtet haben, stellen Sie sicher, dass die folgenden Umgebungsvariablen festgelegt sind:
ANTHROPIC_FOUNDRY_API_KEY="your-foundry-api-key"
ANTHROPIC_FOUNDRY_RESOURCE="your-foundry-resource-name"
Erstellen Sie dann den Agent wie folgt:
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)
Hinweis:
anthropic>=0.74.0muss installiert sein.
Agentfeatures
Funktionstools
Rüsten Sie Ihren Agent mit benutzerdefinierten Funktionen aus:
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)
Streaming-Antworten
Erhalten Sie Antworten, wenn sie generiert werden, um eine bessere Benutzererfahrung zu erzielen:
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()
Gehostete Tools
Anthropic Agents unterstützen gehostete Tools wie Websuche, MCP (Model Context Protocol) und Codeausführung:
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)
Erweitertes Denken (logisches Denken)
Anthropic unterstützt erweiterte Thinking-Funktionen durch das thinking Feature, mit dem das Modell seinen Begründungsprozess anzeigen kann:
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()
Anthropische Fähigkeiten
Anthropic bietet verwaltete Fähigkeiten, die Agentfunktionen erweitern, z. B. das Erstellen von PowerPoint-Präsentationen. Fähigkeiten erfordern die Funktion des Codedolmetschertools:
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.")
Vollständiges Beispiel
# 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())
Den Agent verwenden
Der Agent ist ein Standard Agent und unterstützt alle Standard-Agent-Vorgänge.
Weitere Informationen zum Ausführen und Interagieren mit Agenten finden Sie in den Einführung in Agenten Tutorials.