Strands Agents

https://github.com/strands-agents/harness-sdk
Admin
Strands Agents is a simple yet powerful SDK that takes a model-driven approach to building and...
Tokens:1,328,136
Snippets:9,533
Trust Score:7.8
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Run an example with npm install and npm start

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/examples/README.md

Run from any example directory to install dependencies and start the example.

```bash
npm install
npm start
```

--------------------------------

### Install and run browser agent example

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/examples/browser-agent/README.md

Install dependencies and start the development server for the browser agent example. After running, open the URL (usually http://localhost:5173) and configure API credentials in settings.

```bash
# Install dependencies
npm install

# Start dev server
npm run dev
```

--------------------------------

### Install and Run the Sample App

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/integrations/ag-ui.mdx

Installs dependencies and starts the development server for the sample application.

```bash
npm install && npm run dev
```

--------------------------------

### Set up the docs site locally with git clone, npm install, and npm run dev

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/contribute/contributing/documentation.mdx

Use this to set up the documentation site locally. It clones the repository, installs dependencies, and starts the development server, which automatically reloads on save.

```bash
# Clone the repository
git clone https://github.com/strands-agents/harness-sdk.git
cd harness-sdk/site

# Install dependencies
npm install

# Start the local development server
npm run dev

# Preview at http://localhost:4321

```

--------------------------------

### Native Ollama setup: pull model and start server

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/model-providers/ollama.mdx

Pulls the llama3.1 model and starts the Ollama server for native installation.

```bash
ollama pull llama3.1
```

```bash
ollama serve
```

--------------------------------

### Install and run Strands CLI

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-cli/README.md

Install the CLI globally with npm and run a chat command. The install command provides the `strands` command. The example command asks the agent to summarize the repository.

```bash
npm install -g @strands-agents/cli   # gives you the `strands` command
strands "summarize what this repo does"
```

--------------------------------

### Set up virtual environment and install dev dependencies

Source: https://github.com/strands-agents/harness-sdk/blob/main/harness-py/AGENTS.md

Sets up a virtual environment and installs the package with dev dependencies. The [dev] extra includes optional model providers (OpenAI, Anthropic, Gemini) so the full test suite runs without extra setup.

```bash
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
```

--------------------------------

### Setup commands for the banking email demo

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/blog/strands-agents-with-agent-control.mdx

Commands to clone the agent-control repository, install dependencies, configure environment variables, start the Agent Control server with Docker, set up email controls, and launch the Streamlit demo app.

```bash
git clone https://github.com/agentcontrol/agent-control.git
cd agent-control

# Install the Strands example dependencies
cd examples/strands_agents
uv pip install -e .

# Configure
cp .env.example .env
# Add OPENAI_API_KEY and AGENT_CONTROL_URL

# Start the Agent Control server (requires Docker)
curl -fsSL https://raw.githubusercontent.com/agentcontrol/agent-control/docker-compose.yml | docker compose -f - up -d

# Set up controls on the server (in a new terminal)
cd steering_demo
uv run setup_email_controls.py

# Launch the Streamlit app
streamlit run email_safety_demo.py
```

--------------------------------

### Documentation site: Install and run dev server

Source: https://github.com/strands-agents/harness-sdk/blob/main/README.md

Commands to set up and run the documentation site locally. Starts a dev server at http://localhost:4321/.

```bash
cd site
npm install
npm run dev       # local dev server at http://localhost:4321/
```

--------------------------------

### Install bidi and otel extras

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/observability.mdx

Install both the bidi and otel extras to run the Bedrock Nova Sonic example and export OpenTelemetry data.

```shell
pip install 'strands-agents[bidi,otel]'
```

--------------------------------

### Python Quick Start: Install and Use create_harness()

Source: https://github.com/strands-agents/harness-sdk/blob/main/README.md

Install the Python Strands harness package and create a fully assembled agent with a single create_harness() call. The agent is invoked with a natural language instruction.

```bash
pip install strands-harness
```

```python
from strands_harness import create_harness

agent = create_harness()
agent("Find the slowest test in this repo and explain why it's slow")
```

--------------------------------

### Run complexity analysis with npm

Source: https://github.com/strands-agents/harness-sdk/blob/main/CONTRIBUTING.md

Run from the repository root. The setup command installs the analyzers once; the second command reports labels for your branch compared to origin/main.

```bash
npm run complexity:setup   # once, to install the analyzers
npm run complexity         # report labels for your branch vs origin/main
```

--------------------------------

### Install strands-agents

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/blog/an-agent-for-the-thing-you-keep-putting-off.mdx

Install the strands-agents SDK. This is the starting point for building an agent.

```bash
pip install strands-agents
```

--------------------------------

### Set up Ollama locally

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/learning/switching-model-providers.mdx

Installs Ollama, starts the local server, and pulls the gemma4:latest model. Required before using OllamaModel with host http://localhost:11434.

```bash
brew install ollama
ollama serve
ollama pull gemma4:latest
```

--------------------------------

### Install globally and run strands

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-cli/README.md

Installs the CLI globally and runs the `strands` command. Use this to get the `strands` command available on your system.

```bash
npm install -g @strands-agents/cli
strands
```

--------------------------------

### Create a voice agent with GoogleGeminiLiveModel

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/models/google.mdx

Shows a complete async example that creates a BidiAgent with a GoogleGeminiLiveModel, attaches notebook as a tool, and runs it with AudioIO input and output. Requires the Gemini Live and local audio extras installed.

```python
import asyncio

from strands.bidi.agent import BidiAgent
from strands.bidi.io import AudioIO
from strands.bidi.models import GoogleGeminiLiveModel
from strands.vended_tools import notebook


async def main() -> None:
    model = GoogleGeminiLiveModel(
        model_id="gemini-3.8-live",
        voice="Kore",
        client_args={"api_key": "<GOOGLE_API_KEY>"},
    )
    agent = BidiAgent(model=model, tools=[notebook])

    audio_io = AudioIO()
    await agent.run(inputs=[audio_io.input()], outputs=[audio_io.output()])


if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Basic A2A Server Setup with Agent Factory

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/multi-agent/agent-to-agent.mdx

Basic A2A server setup using an agent factory. The Python example creates a fresh agent per context and starts the server with streaming enabled by default. The TypeScript example shows the imports and an include marker for the actual server code.

```python
import logging
from strands import Agent
from strands.multiagent.a2a import A2AServer
from strands.vended_tools import notebook

logging.basicConfig(level=logging.INFO)

# Build a fresh agent for each A2A context so callers stay isolated
def create_agent(context_id: str) -> Agent:
    return Agent(
        name="Notebook Agent",
        description="A note-taking agent that organizes information in notebooks.",
        tools=[notebook],
        callback_handler=None
    )

# Create A2A server with a per context agent factory (streaming enabled by default)
a2a_server = A2AServer(agent_factory=create_agent)

# Start the server
a2a_server.serve()
```

```typescript
import { Agent } from '@strands-agents/sdk'
import { A2AExpressServer } from '@strands-agents/sdk/a2a/express'

--8<-- "user-guide/sdk/multi-agent/agent-to-agent.ts:basic_server"
```

--------------------------------

### Install bidi-io extras and run ConsoleIO with OpenAIRealtimeModel

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/io.mdx

Install the required extras (`bidi-io` and `bidi-openai`) before running the ConsoleIO example. The Python script creates a BidiAgent with an OpenAIRealtimeModel (gpt-realtime-2.1) and uses ConsoleIO for input and output. Set OPENAI_API_KEY before running; press Enter to send a message and Ctrl-C to exit.

```bash
pip install "strands-agents[bidi-io,bidi-openai]"
```

```python
import asyncio

from strands.bidi.agent import BidiAgent
from strands.bidi.io import ConsoleIO
from strands.bidi.models import OpenAIRealtimeModel


async def main():
    model = OpenAIRealtimeModel(
        model_id="gpt-realtime-2.1",
        transcription_model_id=None,
        params={"output_modalities": ["text"]},
    )
    agent = BidiAgent(model=model)
    console_io = ConsoleIO()

    await agent.run(
        inputs=[console_io.input()],
        outputs=[console_io.output()],
    )


try:
    asyncio.run(main())
except KeyboardInterrupt:
    pass
```

--------------------------------

### Environment Setup Commands

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-py/AGENTS.md

Commands to enter the development environment and install pre-commit hooks. Run these after cloning the repository to set up the local development environment.

```bash
hatch shell                                    # Enter dev environment
pre-commit install -t pre-commit -t commit-msg # Install hooks
```

--------------------------------

### Start SGLang Server

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/model-providers/sglang.mdx

Command to launch an SGLang server with a Qwen model on port 30000. Use this before running the agent examples.

```bash
python -m sglang.launch_server \
    --model-path Qwen/Qwen3-4B-Instruct-2507 \
    --port 30000 \
    --host 0.0.0.0
```

--------------------------------

### Install Strands Harness SDK

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/migrate/langgraph.mdx

Install the Strands Harness SDK for Python or TypeScript before starting the migration.

```bash
pip install strands-agents
```

```bash
npm install @strands-agents/sdk
```

--------------------------------

### Start the UI

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/integrations/ag-ui.mdx

Starts the UI development server to connect to the deployed agent.

```bash
npm run dev:ui
```

--------------------------------

### Install SDK with bidi-pyaudio on Windows

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/quickstart.mdx

Installs the SDK with all bidirectional streaming providers and the bidi-pyaudio extra on Windows. PyAudio typically installs without additional dependencies.

```bash
pip install "strands-agents[bidi-all,bidi-pyaudio]"
```

--------------------------------

### Install strands-google

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/tools/strands-google.mdx

Installs the strands-google package from PyPI.

```bash
pip install strands-google
```

--------------------------------

### Install strands-harness-optimizer

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/blog/introducing-harness-optimizer.mdx

Install the strands-harness-optimizer package from PyPI.

```bash
pip install strands-harness-optimizer
```

--------------------------------

### Build and Start Server

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/docs/examples/typescript/deploy_to_bedrock_agentcore/README.md

Builds the TypeScript project and starts the server locally.

```bash
npm run build
npm start
```

--------------------------------

### Clone and run the browser agent example

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/blog/strands-agents-typescript-sdk.mdx

Clone the repository and run the browser agent example. This example demonstrates an AI agent manipulating a live canvas element through natural language.

```bash
git clone https://github.com/strands-agents/sdk-typescript.git
cd sdk-typescript/strands-ts/examples/browser-agent
npm install && npm run dev
```

--------------------------------

### Quick Setup All-in-One Bash Command for TypeScript Agent

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/typescript.mdx

Optional all-in-one bash command that creates a complete TypeScript agent project with all necessary files (tsconfig.json, index.ts, Dockerfile) and skips the remaining manual setup steps. It installs dependencies, sets npm scripts, and prints a completion message.

```bash
setup_typescript_agent() {
# Create project directory and initialize with npm
mkdir my-typescript-agent && cd my-typescript-agent
npm init -y

# Install required dependencies
npm install @strands-agents/sdk express @types/express typescript ts-node
npm install -D @types/node

# Create TypeScript configuration
cat > tsconfig.json << 'EOF'
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "outDir": "./dist",
    "rootDir": "./",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["*.ts"],
  "exclude": ["node_modules", "dist"]
}
EOF

# Add npm scripts
npm pkg set scripts.build="tsc" scripts.start="node dist/index.js" scripts.dev="ts-node index.ts"

# Create the Express agent application
cat > index.ts << 'EOF'
import { Agent } from '@strands-agents/sdk'
import express, { type Request, type Response } from 'express'
import { OpenAIModel } from '@strands-agents/sdk/models/openai'

const PORT = Number(process.env.PORT) || 8080

// Note: Any supported model provider can be configured
// Automatically uses process.env.OPENAI_API_KEY
const model = new OpenAIModel({ api: 'chat' })

const agent = new Agent({ model })

const app = express()

// Middleware to parse JSON
app.use(express.json())

// Health check endpoint
app.get('/ping', (_: Request, res: Response) =>
  res.json({
    status: 'healthy',
  })
)

// Agent invocation endpoint
app.post('/invocations', async (req: Request, res: Response) => {
  try {
    const { input } = req.body
    const prompt = input?.prompt || ''

    if (!prompt) {
      return res.status(400).json({
        detail: 'No prompt found in input. Please provide a "prompt" key in the input.'
      })
    }

    // Invoke the agent
    const result = await agent.invoke(prompt)

    const response = {
      message: result,
      timestamp: new Date().toISOString(),
      model: 'strands-agent',
    }

    return res.json({ output: response })
  } catch (err) {
    console.error('Error processing request:', err)
    return res.status(500).json({
      detail: `Agent processing failed: ${err instanceof Error ? err.message : 'Unknown error'}`
    })
  }
})

// Start server
app.listen(PORT, '0.0.0.0', () => {
  console.log(`Strands Agent Server listening on port ${PORT}`)
  console.log(`Endpoints:`)
  console.log(`   POST http://0.0.0.0:${PORT}/invocations`)
  console.log(`   GET  http://0.0.0.0:${PORT}/ping`)
})
EOF

# Create Docker configuration
cat > Dockerfile << 'EOF'
# Use Node 22+
FROM node:22

WORKDIR /app

# Copy source code
COPY . ./

# Install dependencies
RUN npm install

# Build TypeScript
RUN npm run build

# Expose port
EXPOSE 8080

# Start the application
CMD ["npm", "start"]
EOF

echo "Setup complete! Project created in my-typescript-agent/"
}

# Run the setup
setup_typescript_agent
```

--------------------------------

### Install strands-hubspot

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/tools/strands-hubspot.mdx

Install the strands-hubspot package from PyPI.

```bash
pip install strands-hubspot
```

--------------------------------

### Create and run a Strands harness with create_harness() / createHarness()

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/harness/index.mdx

Shows how to get a Strands harness running with zero configuration. Import and instantiate the harness, then invoke it with a task. Amazon Bedrock is the default model provider; see the model configuration guide to switch to Anthropic, OpenAI, Google, or Ollama.

```python
# pip install strands-harness
from strands_harness import create_harness

agent = create_harness()
agent("Research the top three vector databases, compare pricing and limits, and write it up in comparison.md")
```

```typescript
// npm install @strands-agents/harness
import { createHarness } from '@strands-agents/harness'

const agent = await createHarness()
await agent.invoke("Research the top three vector databases, compare pricing and limits, and write it up in comparison.md")
```

--------------------------------

### Connect agent to MCP server (Python)

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/tools/mcp-tools.mdx

Quick start example for connecting an agent to an MCP server using the Python SDK. Creates an MCPClient with stdio transport, passes it directly to the Agent, and invokes the agent with a query. The MCP client lifecycle is managed automatically.

```python
from mcp import stdio_client, StdioServerParameters
from strands import Agent
from strands.tools.mcp import MCPClient

# Create MCP client with stdio transport
mcp_client = MCPClient(lambda: stdio_client(
    StdioServerParameters(
        command="uvx",
        args=["awslabs.aws-documentation-mcp-server@latest"]
    )
))

# Pass MCP client directly to agent - lifecycle managed automatically
agent = Agent(tools=[mcp_client])
agent("What is AWS Lambda?")
```

--------------------------------

### Install strands-perplexity

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/tools/strands-perplexity.mdx

Install the strands-perplexity package from PyPI.

```bash
pip install strands-perplexity
```

--------------------------------

### Step 1: Create Project Directory and Initialize

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/python.mdx

Creates the project directory and initializes a Python 3.11 project with uv.

```bash
mkdir my-python-agent && cd my-python-agent
uv init --python 3.11
```

--------------------------------

### Install strands-agents-spraay

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/tools/strands-spraay.mdx

Install the strands-agents-spraay package from PyPI.

```bash
pip install strands-agents-spraay
```

--------------------------------

### Install Google Gemini Live provider

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/models/google.mdx

Install the Google Gemini Live provider and its dependencies. The first command installs the provider with the required I/O and audio packages. The second installs all bidirectional streaming providers at once.

```bash
pip install 'strands-agents[bidi-google,bidi-io,bidi-pyaudio]'
```

```bash
pip install 'strands-agents[bidi-all,bidi-pyaudio]'
```

--------------------------------

### Install dependencies

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/docs/examples/cdk/deploy_to_fargate/README.md

Install Node.js dependencies, create a Python virtual environment, and install Python dependencies for local development.

```bash
# Install Node.js dependencies including CDK and TypeScript locally
npm install

# Create a Python virtual environment (optional but recommended)
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install Python dependencies for the local development
pip install -r ./docker/requirements.txt
```

--------------------------------

### Install and run the documentation site

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/CONTRIBUTING.md

Install dependencies and run the development server or build the static site. The dev server runs at http://localhost:4321/.

```bash
npm install
npm run dev        # starts dev server at http://localhost:4321/
npm run build      # generates static site
```

--------------------------------

### Install uv

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/python.mdx

Installs the uv package manager, which is required for the project setup steps that follow.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Install strands-telegram-listener

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/tools/strands-telegram-listener.mdx

Install the strands-telegram-listener package from PyPI.

```bash
pip install strands-telegram-listener
```

--------------------------------

### Install the AgentCore Runtime Python SDK

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_bedrock_agentcore/python.mdx

Install the AgentCore Runtime Python SDK.

```bash
pip install bedrock-agentcore
```

--------------------------------

### Install strands-code-agent

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/agent-extensions/strands-code-agent.mdx

Install the strands-code-agent package from PyPI.

```bash
pip install strands-code-agent
```

--------------------------------

### Developer example with PyAudio and console IO

Source: https://github.com/strands-agents/harness-sdk/blob/main/team/designs/0015-bidi-webrtc-design.md

Shows how to instantiate a BidiAgent with a BedrockNovaSonicModel, attach audio and console IO, and run with mic input and speaker/transcript output.

```python
from strands.experimental.bidi.agent import BidiAgent
from strands.experimental.bidi.io import AudioIO, ConsoleIO
from strands.experimental.bidi.models import BedrockNovaSonicModel

agent = BidiAgent(model=BedrockNovaSonicModel(), tools=[my_tool], system_prompt="You are a helpful assistant.")
audio_io = AudioIO()
text_io = ConsoleIO()

# Mic audio in, speaker audio + transcript text out
await agent.run(
    inputs=[audio_io.input()],
    outputs=[audio_io.output(), text_io.output()],
)
```

--------------------------------

### Install Strands Evals SDK

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/blog/framework-agnostic-evaluation-strands-evals.mdx

Install the Strands Evals SDK to start evaluating agents in a framework-agnostic way.

```bash
pip install strands-agents-evals
```

--------------------------------

### Create Project Directory and Initialize npm

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/typescript.mdx

Creates the project directory and initializes it with npm using default settings.

```bash
mkdir my-typescript-agent && cd my-typescript-agent
npm init -y
```

--------------------------------

### Install Hatch and run tests, format, and lint

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-py/README.md

Install the Hatch build tool, then run unit tests and format/lint the codebase. The comments indicate the purpose of each command.

```bash
pip install hatch
hatch test        # run unit tests
hatch fmt         # format & lint
```

--------------------------------

### Install TypeScript SDK and OpenAI

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/model-providers/openai-responses.mdx

Install the TypeScript SDK and the OpenAI package.

```bash
npm install @strands-agents/sdk openai
```

--------------------------------

### TypeScript Quick Start: Install and Use createHarness()

Source: https://github.com/strands-agents/harness-sdk/blob/main/README.md

Install the TypeScript Strands harness package and create a fully assembled agent with a single createHarness() call. The agent is invoked with the invoke() method.

```bash
npm install @strands-agents/harness
```

```typescript
import { createHarness } from '@strands-agents/harness'

const agent = await createHarness()
await agent.invoke("Find the slowest test in this repo and explain why it's slow")
```

--------------------------------

### Quick Setup All-in-One Bash Command

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/python.mdx

Optional all-in-one bash command that creates the project directory, initializes uv, adds dependencies, writes agent.py and Dockerfile, and prints a completion message. It removes the auto-generated main.py and uses the OpenAI model by default.

```bash
setup_agent() {
mkdir my-python-agent && cd my-python-agent
uv init --python 3.11
uv add fastapi "uvicorn[standard]" pydantic strands-agents "strands-agents[openai]"

# Remove the auto-generated main.py
rm -f main.py

cat > agent.py << 'EOF'
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Dict, Any
from datetime import datetime, timezone
from strands import Agent
from strands.models.openai import OpenAIModel

app = FastAPI(title="Strands Agent Server", version="1.0.0")

# Note: Any supported model provider can be configured
# Automatically uses process.env.OPENAI_API_KEY
model = OpenAIModel(model_id="gpt-4o")

strands_agent = Agent(model=model)

class InvocationRequest(BaseModel):
    input: Dict[str, Any]

class InvocationResponse(BaseModel):
    output: Dict[str, Any]

@app.post("/invocations", response_model=InvocationResponse)
async def invoke_agent(request: InvocationRequest):
    try:
        user_message = request.input.get("prompt", "")
        if not user_message:
            raise HTTPException(
                status_code=400,
                detail="No prompt found in input. Please provide a 'prompt' key in the input."
            )

        result = strands_agent(user_message)
        response = {
            "message": result.message,
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "model": "strands-agent",
        }

        return InvocationResponse(output=response)

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Agent processing failed: {str(e)}")

@app.get("/ping")
async def ping():
    return {"status": "healthy"}

def main():
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)

if __name__ == "__main__":
    main()
EOF

cat > Dockerfile << 'EOF'
# Use uv's Python base image
FROM ghcr.io/astral-sh/uv:python3.11-bookworm-slim

WORKDIR /app

# Copy uv files
COPY pyproject.toml uv.lock ./

# Install dependencies
RUN uv sync --frozen --no-cache

# Copy agent file
COPY agent.py ./

# Expose port
EXPOSE 8080

# Run application
CMD ["uv", "run", "python", "agent.py"]
EOF

echo "Setup complete! Project created in my-python-agent/"
}

setup_agent
```

--------------------------------

### Setup Docker buildx

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_bedrock_agentcore/python.mdx

Sets up Docker buildx for multi-platform builds, required before building the ARM64 image.

```bash
docker buildx create --use
```

--------------------------------

### Good Logging Examples

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-py/docs/STYLE_GUIDE.md

Good logging examples: each log starts with structured field pairs, uses %s or %d for interpolation, and ends with a lowercase human-readable message without punctuation. Separate multiple statements with a pipe character.

```python
logger.debug("user_id=<%s>, action=<%s> | user performed action", user_id, action)
logger.info("request_id=<%s>, duration_ms=<%d> | request completed", request_id, duration)
logger.warning("attempt=<%d>, max_attempts=<%d> | retry limit approaching", attempt, max_attempts)
```

--------------------------------

### Install Python Dependencies for ARM64 Lambda

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_aws_lambda.mdx

Installs Python dependencies for an ARM64 Lambda environment, matching the architecture used in the CDK example. Use this when building a custom layer to avoid runtime errors from incompatible binaries.

```shell
# Install Python dependencies for lambda with correct architecture
pip install -r requirements.txt \
    --python-version 3.12 \
    --platform manylinux2014_aarch64 \
    --target ./packaging/_dependencies \
    --only-binary=:all:
```

--------------------------------

### Full example with all features

Source: https://github.com/strands-agents/harness-sdk/blob/main/team/designs/0006-cedar-authorization.md

Complete example showing the CedarAuthPlugin with policies, entities, principal_resolver, and resource_resolver, then invoking an agent with the plugin and a tool call.

```python
plugin = CedarAuthPlugin(
    policies=Path("./cedar/policies.cedar"),
    entities=my_entity_provider,         # callable, list, or file path
    principal_resolver=resolve_any,
    resource_resolver={                   # or "./resources.json"
        "terminate_ec2_instance": {"key": "instance_id", "type": "Instance"},
    },
)

agent = Agent(plugins=[plugin], tools=[...])
agent("terminate instance i-abc123", invocation_state={"user_id": "alice@acme.com"})
```

--------------------------------

### Poor Logging Examples

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-py/docs/STYLE_GUIDE.md

Poor logging examples to avoid: direct f-string interpolation, inconsistent formatting with punctuation, and missing separation between fields and message. These violate the style guide's requirements for structured, parseable logs.

```python
# Avoid: No structured fields, direct variable interpolation in message
logger.debug(f"User {user_id} performed action {action}")

# Avoid: Inconsistent formatting, punctuation
logger.info("Request completed in %d ms.", duration)

# Avoid: No separation between fields and message
logger.warning("Retry limit approaching! attempt=%d max_attempts=%d", attempt, max_attempts)
```

--------------------------------

### Install agent-control-sdk with strands-agents extra

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/blog/strands-agents-with-agent-control.mdx

Install the SDK with the strands-agents extra using pip.

```bash
pip install "agent-control-sdk[strands-agents]"
```

--------------------------------

### Basic GithubStorage setup (Python and TypeScript)

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/storage/github.mdx

Basic setup showing the four-method Storage interface (write, read, list, delete) with GithubStorage. The branch defaults to 'main'; a token is required for writes and private repos. Python read returns bytes or None; TypeScript read returns Uint8Array or null.

```python
import asyncio
from strands_github_storage import GithubStorage

storage = GithubStorage(
    owner="myorg",
    repo="agent-memory",
    branch="main",          # optional, defaults to "main"
    token="ghp_...",        # required for writes and private repos
)

async def main() -> None:
    await storage.write("facts/note.md", b"remember this")
    data = await storage.read("facts/note.md")   # bytes | None
    keys = await storage.list("facts/")          # ["facts/note.md"]
    await storage.delete("facts/note.md")

asyncio.run(main())
```

```typescript
import { GithubStorage } from 'strands-github-storage'

const storage = new GithubStorage({
  owner: 'myorg',
  repo: 'agent-memory',
  branch: 'main', // optional, defaults to 'main'
  token: process.env.GITHUB_TOKEN, // required for writes and private repos
})

await storage.write('facts/note.md', new TextEncoder().encode('remember this'))
const bytes = await storage.read('facts/note.md') // Uint8Array | null
const keys = await storage.list('facts/') // ['facts/note.md']
await storage.delete('facts/note.md')
```

--------------------------------

### Start from an agent file or override the model

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/harness/quickstart.mdx

Shows two CLI flags for the `strands` command: `--agent` starts from an existing exported agent file (skipping setup), and `--model` overrides the saved model for a single run.

```bash
strands --agent ./agent.ts                     # start from an exported agent
strands --model anthropic/claude-sonnet-5      # use a different model for this run
```

--------------------------------

### Setup and run linked dev command

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-cli/README.md

Installs CLI dependencies and links the `strands-dev` command to this checkout. Run from the repository root.

```bash
npm run setup
strands-dev
```

--------------------------------

### Complete example with a Strands agent

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/safety-security/pii-redaction.mdx

Full integration example showing how to set up LLM Guard and Langfuse masking, define a Strands agent, and process a sanitized payload.

```python
from strands import Agent
from llm_guard.vault import Vault
from llm_guard.input_scanners import Anonymize
from llm_guard.input_scanners.anonymize_helpers import BERT_LARGE_NER_CONF
from langfuse import Langfuse, observe

vault = Vault()

def create_anonymize_scanner():
    """Creates a reusable anonymize scanner."""
    return Anonymize(vault, recognizer_conf=BERT_LARGE_NER_CONF, language="en")

def masking_function(data, **kwargs):
    """Langfuse masking function to recursively redact PII."""
    if isinstance(data, str):
        scanner = create_anonymize_scanner()
        sanitized_data, _, _ = scanner.scan(data)
        return sanitized_data
    elif isinstance(data, dict):
        return {k: masking_function(v) for k, v in data.items()}
    elif isinstance(data, list):
        return [masking_function(item) for item in data]
    return data

langfuse = Langfuse(mask=masking_function)


class CustomerSupportAgent:
    def __init__(self):
        self.agent = Agent(
            system_prompt="You are a helpful customer service agent. Respond professionally to customer inquiries."
        )

    @observe
    def process_sanitized_message(self, sanitized_payload):
        """Processes a pre-sanitized payload and expects sanitized input."""
        sanitized_content = sanitized_payload.get("prompt", "empty input")

        conversation = f"Customer: {sanitized_content}"

        response = self.agent(conversation)
        return response


def process():
    support_agent = CustomerSupportAgent()
    scanner = create_anonymize_scanner()

    raw_payload = {
        "prompt": "Hi, I'm Jonny Test. My phone number is 123-456-7890 and my email is john@example.com. I need help with my order #123456789."
    }

    sanitized_prompt, _, _ = scanner.scan(raw_payload["prompt"])
    sanitized_payload = {"prompt": sanitized_prompt}

    response = support_agent.process_sanitized_message(sanitized_payload)

    print(f"Response: {response}")
    langfuse.flush()
    
    #Example input: prompt:
        # "Hi, I'm [REDACTED_PERSON_1]. My phone number is [REDACTED_PHONE_NUMBER_1] and my email is [REDACTED_EMAIL_ADDRESS_1]. I need help with my order #123456789."
    #Example output: 
        # #Hello! I'd be happy to help you with your order #123456789. 
        # To better assist you, could you please let me know what specific issue you're experiencing with this order? For example:
        # - Are you looking for a status update?
        # - Need to make changes to the order?
        # - Having delivery issues?
        # - Need to process a return or exchange?
        # 
        # Once I understand what you need help with, I'll be able to provide you with the most relevant assistance."

if __name__ == "__main__":
    process()
```

--------------------------------

### Restart bash session

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/src/vended-tools/bash/README.md

Clear all session state and start fresh. This example sets a variable, restarts the session, and then verifies the variable is gone.

```typescript
import { Agent } from '@strands-agents/sdk'
import { BedrockModel } from '@strands-agents/sdk'
import { bash } from '@strands-agents/sdk/vended-tools/bash'

const model = new BedrockModel({
  region: 'us-east-1',
})

const agent = new Agent({
  model,
  tools: [bash],
})

// Set a variable
let res = await agent.invoke('run export "TEMP_VAR=exists"')

// Restart the session
res = await agent.invoke('restart the bash session')

// Variable is now gone
res = await agent.invoke('run "echo $TEMP_VAR"')
console.log(res.lastMessage) // Variable will be empty/undefined
```

--------------------------------

### TypeScript ModelStreamEvent interface examples

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/model-providers/custom_model_provider.mdx

TypeScript examples for ModelMessageStartEventData and ModelContentBlockStartEventData. The messageStart event sets role to 'assistant'. The contentBlockStart event can be a plain object for text blocks or include a start object with type 'toolUseStart', toolUseId, and name for tool use blocks.

```typescript
const messageStart: ModelMessageStartEventData = {
  type: 'modelMessageStartEvent',
  role: 'assistant',
}
```

```typescript
// For text blocks
const textBlockStart: ModelContentBlockStartEventData = {
  type: 'modelContentBlockStartEvent',
}

// For tool use blocks
const toolUseStart: ModelContentBlockStartEventData = {
  type: 'modelContentBlockStartEvent',
  start: {
    type: 'toolUseStart',
    toolUseId: 'tool_123',
    name: 'calculator',
  },
}
```

--------------------------------

### Run the tracing example with OTLP endpoint

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-ts/examples/telemetry/README.md

Runs the example, setting the OTLP exporter endpoint to the local OTel Collector. Requires Node.js 22+ and AWS credentials for Bedrock model access.

```bash
OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318 npm start
```

--------------------------------

### Create Dockerfile for TypeScript Agent

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/typescript.mdx

Dockerfile that uses Node 22, copies source, installs dependencies, builds TypeScript, exposes port 8080, and starts the application.

```dockerfile
# Use Node 22+
FROM node:22

WORKDIR /app

# Copy source code
COPY . ./

# Install dependencies
RUN npm install

# Build TypeScript
RUN npm run build

# Expose port
EXPOSE 8080

# Start the application
CMD ["npm", "start"]
```

--------------------------------

### Configure agent with agentcore configure

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/integrations/integrations/ag-ui.mdx

Navigates to the agent directory and starts the AgentCore configuration wizard. Respond to the prompts to set up the agent.

```bash
cd agent
agentcore configure -e main.py
```

--------------------------------

### Create Dockerfile for Deployment

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_bedrock_agentcore/typescript.mdx

Multi-stage Dockerfile for building and running the TypeScript service on ARM64. Copies source, installs dependencies, builds, exposes port 8080, and starts the app.

```dockerfile
FROM --platform=linux/arm64 public.ecr.aws/docker/library/node:latest

WORKDIR /app

# Copy source code
COPY . ./

# Install dependencies
RUN npm install

# Build TypeScript
RUN npm run build

# Expose port
EXPOSE 8080

# Start the application
CMD ["npm", "start"]
```

--------------------------------

### Set up and run the MCP inspector

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-mcp/README.md

Clones the repository, sets up a Python virtual environment, installs the package in development mode, and launches the MCP inspector against the strands_mcp_server.

```bash
git clone https://github.com/strands-agents/harness-sdk.git
cd harness-sdk/strands-mcp
python3 -m venv venv
source venv/bin/activate
pip3 install -e ".[dev]"

npx @modelcontextprotocol/inspector python -m strands_mcp_server
```

--------------------------------

### Install SDK for Google Gemini Live

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/quickstart.mdx

Installs the SDK for Google Gemini Live with either local audio I/O (bidi-pyaudio) or terminal text I/O (bidi-io).

```bash
# With local audio I/O
pip install "strands-agents[bidi-google,bidi-io,bidi-pyaudio]"

# With terminal text I/O
pip install "strands-agents[bidi-google,bidi-io]"
```

--------------------------------

### Attach a plugin to an agent with the plugins parameter (TypeScript)

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/plugins/custom-plugins.mdx

Use the plugins parameter when creating an Agent to attach a plugin. The example shows importing LLMSteeringHandler and passing it with a system_prompt to guide the agent.

```typescript
--8<-- "user-guide/sdk/plugins/custom-plugins_imports.ts:using_plugins_imports"

--8<-- "user-guide/sdk/plugins/custom-plugins.ts:using_plugins"
```

--------------------------------

### Attach a plugin to an agent with the plugins parameter (Python)

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/plugins/custom-plugins.mdx

Use the plugins parameter when creating an Agent to attach a plugin. The example shows importing LLMSteeringHandler and passing it with a system_prompt to guide the agent.

```python
from strands import Agent
from strands.vended_plugins.steering import LLMSteeringHandler

# Create an agent with plugins
agent = Agent(
    tools=[my_tool],
    plugins=[LLMSteeringHandler(system_prompt="Guide the agent...")]
)
```

--------------------------------

### Python SDK: Install and run an agent with a tool

Source: https://github.com/strands-agents/harness-sdk/blob/main/README.md

Install the Python SDK and create an agent with a calculator tool, then invoke it with a question.

```bash
pip install strands-agents strands-agents-tools
```

```python
from strands import Agent
from strands_tools import calculator

agent = Agent(tools=[calculator])
agent("What is the square root of 1764")
```

--------------------------------

### Galileo Agent Control plugins usage in Python

Source: https://github.com/strands-agents/harness-sdk/blob/main/team/designs/0007-intervention-primitive.md

Python example showing how to use the two complementary Galileo Agent Control plugins: AgentControlPlugin for Deny and AgentControlSteeringHandler for Guide. Both are attached to the same Agent.

```python
from agent_control.integrations.strands import AgentControlPlugin, AgentControlSteeringHandler

blocker = AgentControlPlugin(agent_name="my-agent")
guide = AgentControlSteeringHandler(agent_name="my-agent")

agent = Agent(tools=[search, send_email], plugins=[blocker, guide])
```

--------------------------------

### Python SDK: Install hatch and run tests

Source: https://github.com/strands-agents/harness-sdk/blob/main/README.md

Commands to set up and run the Python SDK toolchain. Requires changing into the strands-py directory and installing hatch before running tests and formatting.

```bash
cd strands-py
pip install hatch
hatch test        # run unit tests
hatch fmt         # format & lint
```

--------------------------------

### BidiAgent bidirectional streaming example

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/agent.mdx

Shows BidiAgent setup for real-time bidirectional streaming: persistent connection, continuous audio input/output, and concurrent tool execution. Use for voice assistants and live transcription.

```python
import asyncio
from strands.bidi.agent import BidiAgent
from strands.bidi.io import AudioIO
from strands.bidi.models import BedrockNovaSonicModel

model = BedrockNovaSonicModel(model_id="amazon.nova-2-sonic-v1:0")
agent = BidiAgent(model=model, tools=[notebook])
audio_io = AudioIO()

async def main():
    # Persistent connection with continuous streaming
    await agent.run(
        inputs=[audio_io.input()],
        outputs=[audio_io.output()]
    )

asyncio.run(main())
```

--------------------------------

### Deploy with CDK and Podman

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_aws_apprunner.mdx

Commands to bootstrap the AWS environment, start Podman, and deploy the CDK stack. Requires Python and Node dependencies installed. Uses CDK_DOCKER=podman to use Podman as the Docker engine.

```bash
# Bootstrap your AWS environment (if not already done)
npx cdk bootstrap

# Ensure Docker or Podman is running
podman machine start 

# Deploy the stack
CDK_DOCKER=podman npx cdk deploy  
```

--------------------------------

### Create virtual environment and install

Source: https://github.com/strands-agents/harness-sdk/blob/main/strands-py/README.md

Sets up a virtual environment and installs Strands Agents and tools. Requires Python 3.10+.

```bash
# Create and activate virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows use: .venv\Scripts\activate

# Install Strands and tools
pip install strands-agents strands-agents-tools
```

--------------------------------

### Initialize LlamaCppModel and run agent

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/model-providers/llamacpp.mdx

Import and initialize the llama.cpp provider, create an agent with a notebook tool, and run a prompt. The model is configured with a base URL, model ID, and sampling parameters.

```python
from strands import Agent
from strands.models.llamacpp import LlamaCppModel
from strands.vended_tools import notebook

model = LlamaCppModel(
    base_url="http://localhost:8080",
    # **model_config
    model_id="default",
    params={
        "max_tokens": 1000,
        "temperature": 0.7,
        "repeat_penalty": 1.1,
    }
)

agent = Agent(model=model, tools=[notebook])
response = agent('Create a notebook named "ideas" and add three project ideas.')
print(response)
```

--------------------------------

### Docker Compose Commands for Local Development

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_docker/python.mdx

Commands to manage the Docker Compose setup. Use docker-compose up --build to start services, docker-compose up -d --build to run in the background, and docker-compose down to stop services.

```bash
# Start services
docker-compose up --build

# Run in background
docker-compose up -d --build

# Stop services
docker-compose down
```

--------------------------------

### Run agent with Ollama (local)

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/quickstart/python.mdx

Installs the Ollama extra, starts the Ollama server, pulls the llama3.1 model, and runs an agent with the OllamaModel pointing at http://localhost:11434. Runs models locally with no API key or cloud account needed.

```bash
pip install 'strands-agents[ollama]'
ollama serve
ollama pull llama3.1
```

```python
from strands import Agent
from strands.models.ollama import OllamaModel

model = OllamaModel(host="http://localhost:11434", model_id="llama3.1")
agent = Agent(model=model)
agent("What is an agent harness, in one sentence?")
```

--------------------------------

### SKILL.md example with frontmatter and instructions

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/plugins/skills.mdx

Example of a SKILL.md file with YAML frontmatter (name, description, allowed-tools) and markdown instructions. The allowed-tools field is informational and not enforced at runtime.

```markdown
---
name: pdf-processing
description: Extract text and tables from PDF files
allowed-tools: file_editor shell
---
# PDF processing

You are a PDF processing expert. When asked to extract content from a PDF:

1. Use `shell` to run the extraction script at `scripts/extract.py`
2. Use `file_editor` to review the output
3. Summarize the extracted content for the user

```

--------------------------------

### Test the Deployed Service Using the Application Load Balancer URLs: Get Service URL and Call Endpoints

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/deploy/deploy_to_aws_fargate.mdx

Once the stack is deployed you can test your agent using the Application Load Balancer Retrieves the service URL from the CDK example output ExportName=='AgentServiceEndpoint' and then uses `curl to POST to the /weather endpoint with a JSON payload asking about Seattle and separately to the /weather-streaming endpoint with a JSON payload asking about New York Celsius It assumes the service is already deployed and accessible at the returned URL and expects the service to respond appropriately for both the regular and streaming endpoints It also assumes that the `jq utility is not required for these examples and relies on command substitution to capture the URL from the AWS CLI output and pipes it into the curl commands, and expects the service to be listening on HTTP (not HTTPS, as indicated by the URLs starting with `http://` and the use of the `-X POST

```bash
# Get the service URL from the 
```

--------------------------------

### Create a voice agent with Bedrock Nova Sonic

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/models/bedrock.mdx

After installing the Bedrock Nova Sonic and local audio extras, create a voice agent using BedrockNovaSonicModel, BidiAgent, and AudioIO. The example uses the 'amazon.nova-2-sonic-v1:0' model in the 'us-east-1' region with the 'tiffany' voice.

```python
import asyncio

from strands.bidi.agent import BidiAgent
from strands.bidi.io import AudioIO
from strands.bidi.models import BedrockNovaSonicModel
from strands.vended_tools import notebook


async def main() -> None:
    model = BedrockNovaSonicModel(
        model_id="amazon.nova-2-sonic-v1:0",
        region="us-east-1",
        voice="tiffany",
    )
    agent = BidiAgent(model=model, tools=[notebook])
    audio_io = AudioIO()
    await agent.run(inputs=[audio_io.input()], outputs=[audio_io.output()])


if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Enable audio echo cancellation with AudioIO(audio_processor=True)

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/quickstart.mdx

Install the optional dependencies for audio processing and enable echo cancellation by passing audio_processor=True to AudioIO. Use a headset or this setup to prevent the agent's playback from triggering barge-in over open speakers.

```bash
pip install "strands-agents[bidi,bidi-pyaudio,bidi-aec]"
```

```python
audio_io = AudioIO(audio_processor=True)
```

--------------------------------

### Install all bidirectional streaming providers

Source: https://github.com/strands-agents/harness-sdk/blob/main/site/src/content/docs/user-guide/sdk/bidi/models/bedrock.mdx

Install all bidirectional streaming providers at once, including Nova Sonic and local audio extras.

```bash
pip install 'strands-agents[bidi-all,bidi-pyaudio]'
```
Tokens:
Raw