AWS Strands

# For LiteLLM (most common)
pip install litellm

# For observability
pip install opentelemetry-api opentelemetry-sdk

# For specific providers
pip install anthropic  # For Claude
pip install openai     # For OpenAI

from strands import Agent
from strands.models.litellm import LiteLLMModel
from strands_tools import http_request
import os

# Configure model
model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
    params={"max_tokens": 1500, "temperature": 0.7},
)

# Create agent
agent = Agent(
    system_prompt="You are a helpful weather assistant",
    tools=[http_request],
    model=model,
)

# Use agent
response = agent("What's the weather in NYC?")
print(response)

from strands import Agent
from strands.session.file_session_manager import FileSessionManager
from pathlib import Path

# Setup session storage
storage_dir = Path("./sessions")
session_manager = FileSessionManager(
    session_id="user_123",
    storage_dir=str(storage_dir),
)

# Agent with memory
agent = Agent(
    model=model,
    session_manager=session_manager,
    system_prompt="You are a friendly assistant",
)

# Conversation is automatically persisted
response1 = agent("My name is Alice")
response2 = agent("What's my name?")  # Remembers "Alice"

import os
from dotenv import load_dotenv
from strands import Agent
from strands.models.litellm import LiteLLMModel
from strands_tools import http_request

load_dotenv()

WEATHER_PROMPT = """
You are a weather assistant with HTTP capabilities.
Use the National Weather Service API:
1. Get coordinates: https://api.weather.gov/points/{latitude},{longitude}
2. Use returned forecast URL to get weather data
3. Present information in a clear, user-friendly format
"""

model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
    params={"max_tokens": 1500, "temperature": 0.7},
)

agent = Agent(
    system_prompt=WEATHER_PROMPT,
    tools=[http_request],
    model=model,
)

response = agent("Compare temperature in New York and Chicago")
print(response)

from strands import Agent, tool
from strands.models.litellm import LiteLLMModel

@tool
def request_human_input(question: str) -> str:
    """
    Ask the human user for input.
    
    Args:
        question: What to ask the user
    
    Returns:
        User's response
    """
    print(f"\n🤖 Agent asks: {question}")
    return input("👤 Your answer: ")

@tool
def request_approval(action: str, details: str) -> bool:
    """
    Request human approval before taking an action.
    
    Args:
        action: Action to perform
        details: Details about the action
    
    Returns:
        True if approved, False otherwise
    """
    print(f"\n🤖 Agent requests approval:")
    print(f"   Action: {action}")
    print(f"   Details: {details}")
    response = input("👤 Approve? (yes/no): ")
    return response.lower() in ['yes', 'y']

model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
)

agent = Agent(
    system_prompt="""
    You help users complete tasks, but must:
    1. Ask for clarification when needed using request_human_input
    2. Get approval before sensitive actions using request_approval
    """,
    tools=[request_human_input, request_approval],
    model=model,
)

response = agent("Send an email to the team about the project update")

from strands import Agent, tool
from strands.models.litellm import LiteLLMModel
import os

model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
)

# Specialized agents
tech_agent = Agent(
    system_prompt="You are a technical support specialist.",
    model=model,
)

billing_agent = Agent(
    system_prompt="You are a billing specialist.",
    model=model,
)

# Tools for handoff
@tool
def handoff_to_tech(issue: str) -> str:
    """Transfer to technical support."""
    return tech_agent(f"Handle this tech issue: {issue}")

@tool
def handoff_to_billing(query: str) -> str:
    """Transfer to billing department."""
    return billing_agent(f"Handle this billing query: {query}")

# Orchestrator agent
triage_agent = Agent(
    system_prompt="""
    You are a customer service triage agent.
    Route technical issues to tech support.
    Route billing questions to billing.
    """,
    tools=[handoff_to_tech, handoff_to_billing],
    model=model,
)

response = triage_agent("My account was charged twice")

import os
from strands import Agent
from strands.models.litellm import LiteLLMModel
from strands.tools.mcp import MCPToolkit

model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
)

# Connect to MCP server (e.g., GitHub)
mcp_toolkit = MCPToolkit(
    server_command="npx",
    server_args=["-y", "@modelcontextprotocol/server-github"],
    env_vars={
        "GITHUB_PERSONAL_ACCESS_TOKEN": os.getenv("GITHUB_TOKEN")
    }
)

agent = Agent(
    system_prompt="You can interact with GitHub repositories",
    tools=[mcp_toolkit],
    model=model,
)

response = agent("List recent issues in owner/repo")

# .env file
NEBIUS_API_KEY=your_nebius_api_key
OPENAI_API_KEY=your_openai_api_key  # If using OpenAI
ANTHROPIC_API_KEY=your_anthropic_api_key  # If using Claude

# For MCP servers
GITHUB_PERSONAL_ACCESS_TOKEN=your_github_token