Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Microsoft Agent Framework admite la creación de agentes que usan los modelos de Claude de Anthropic.
Introducción
Agregue los paquetes NuGet necesarios al proyecto.
dotnet add package Microsoft.Agents.AI.Anthropic --prerelease
Si usa Azure Foundry, agregue también:
dotnet add package Anthropic.Foundry --prerelease
dotnet add package Azure.Identity
Configuración
Variables de entorno
Configure las variables de entorno necesarias para la autenticación antrópica:
# 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
Puede obtener una clave de API desde la consola antrópica.
Para Azure Foundry con clave de API
$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"
Para Azure Foundry con la CLI de Azure
$env:ANTHROPIC_RESOURCE="your-foundry-resource-name" # Subdomain before .services.ai.azure.com
$env:ANTHROPIC_DEPLOYMENT_NAME="claude-haiku-4-5"
Nota:
Al usar Azure Foundry con la CLI de Azure, asegúrese de haber iniciado sesión con az login y de tener acceso al recurso de Azure Foundry. Para más información, consulte la documentación de la CLI de Azure.
Creación de un agente antrópico
Creación básica de agentes (API pública antrópica)
La manera más sencilla de crear un agente antrópico mediante la API pública:
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?"));
Uso de Anthropic en Azure Foundry con clave de API
Después de configurar Anthropic en Azure Foundry, puede usarlo con la autenticación de clave de 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?"));
Uso de Anthropic en Azure Foundry con credenciales de Azure (ejemplo de credenciales de la CLI de Azure)
Para entornos en los que se prefieren las credenciales de 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);
}
}
Advertencia
DefaultAzureCredential es conveniente para el desarrollo, pero requiere una consideración cuidadosa en producción. En producción, considere usar una credencial específica (por ejemplo, ManagedIdentityCredential) para evitar problemas de latencia, sondeos de credenciales no deseados y posibles riesgos de seguridad de los mecanismos de respaldo.
Sugerencia
Consulte los ejemplos de .NET para obtener ejemplos completos de ejecución.
Uso del agente
El agente es un estándar AIAgent y admite todas las operaciones estándar.
Consulte los tutoriales de introducción del agente para obtener más información sobre cómo ejecutar e interactuar con agentes.
Prerrequisitos
Instale el paquete Anthropic de Microsoft Agent Framework.
pip install agent-framework-anthropic --pre
Configuración
Variables de entorno
Configure las variables de entorno necesarias para la autenticación antrópica:
# 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
Como alternativa, puede usar un .env archivo en la raíz del proyecto:
ANTHROPIC_API_KEY=your-anthropic-api-key
ANTHROPIC_CHAT_MODEL_ID=claude-sonnet-4-5-20250929
Puede obtener una clave de API desde la consola antrópica.
Introducción
Importe las clases necesarias desde Agent Framework:
import asyncio
from agent_framework.anthropic import AnthropicClient
Creación de un agente antrópico
Creación básica del agente
La manera más sencilla de crear un agente antrópico:
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)
Uso de la configuración explícita
Puede proporcionar una configuración explícita en lugar de confiar en variables de entorno:
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)
Uso de Anthropic en Foundry
Después de configurar Anthropic en Foundry, asegúrese de que tiene establecidas las siguientes variables de entorno:
ANTHROPIC_FOUNDRY_API_KEY="your-foundry-api-key"
ANTHROPIC_FOUNDRY_RESOURCE="your-foundry-resource-name"
A continuación, cree el agente de la siguiente manera:
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)
Nota: Esto requiere que
anthropic>=0.74.0sea instalado.
Características del agente
Herramientas de funciones
Equipe al agente con funciones personalizadas:
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)
Respuestas de streaming
Obtenga respuestas a medida que se generen para mejorar la experiencia del usuario:
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()
Herramientas hospedadas
Los agentes antrópicos admiten herramientas hospedadas, como búsqueda web, MCP (Protocolo de contexto de modelo) y ejecución de código:
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)
Pensamiento extendido (razonamiento)
Anthropic admite capacidades de pensamiento extendidas a través de la thinking característica, lo que permite al modelo mostrar su proceso de razonamiento:
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()
Aptitudes antrópicas
Anthropic proporciona aptitudes administradas que amplían las funcionalidades del agente, como la creación de presentaciones de PowerPoint. Las aptitudes requieren la herramienta de intérprete de código para funcionar:
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.")
Ejemplo completo
# 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())
Uso del agente
El agente es un estándar Agent y admite todas las operaciones estándar.
Consulte los tutoriales de introducción del agente para obtener más información sobre cómo ejecutar e interactuar con agentes.