Strands Agents Tools

A model-driven approach to building AI agents in just a few lines of code.

Documentation ◆ Samples ◆ Python SDK ◆ Tools ◆ Agent Builder ◆ MCP Server

Strands Agents Tools is a community-driven project that provides a powerful set of tools for your agents to use. It bridges the gap between large language models and practical applications by offering ready-to-use tools for file operations, system execution, API interactions, mathematical operations, and more.

✨ Features

• 📁 File Operations - Read, write, and edit files with syntax highlighting and intelligent modifications
• 🖥️ Shell Integration - Execute and interact with shell commands securely
• 🧠 Memory - Store user and agent memories across agent runs to provide personalized experiences with both Mem0, Amazon Bedrock Knowledge Bases, Elasticsearch, and MongoDB Atlas
• 🕸️ Web Infrastructure - Perform web searches, extract page content, and crawl websites with Tavily and Exa-powered tools
• 🌐 HTTP Client - Make API requests with comprehensive authentication support
• 💬 Slack Client - Real-time Slack events, message processing, and Slack API access
• 🐍 Python Execution - Run Python code snippets with state persistence, user confirmation for code execution, and safety features
• 🧮 Mathematical Tools - Perform advanced calculations with symbolic math capabilities
• ☁️ AWS Integration - Seamless access to AWS services
• 🖼️ Image Processing - Generate and process images for AI applications
• 🎥 Video Processing - Use models and agents to generate dynamic videos
• 🎙️ Audio Output - Enable models to generate audio and speak
• 🔄 Environment Management - Handle environment variables safely
• 📝 Journaling - Create and manage structured logs and journals
• ⏱️ Task Scheduling - Schedule and manage cron jobs
• 🧠 Advanced Reasoning - Tools for complex thinking and reasoning capabilities
• 🐝 Swarm Intelligence - Coordinate multiple AI agents for parallel problem solving with shared memory
• 🤖 Agent as Tool - Create nested agent instances with model switching support for multi-model workflows and specialized sub-tasks
• 🔗 Multi-Agent Graph - Create and manage deterministic DAG-based multi-agent pipelines with output propagation and per-node model configuration
• 🔌 Dynamic MCP Client - ⚠️ Dynamically connect to external MCP servers and load remote tools (use with caution - see security warnings)
• 🔄 Multiple Tools per Turn - Call several other tools from one model response with Batch Tool
• 🔍 Browser Tool - Tool giving an agent access to perform automated actions on a browser (chromium)
• 📈 Diagram - Create AWS cloud diagrams, basic diagrams, or UML diagrams using python libraries
• 📰 RSS Feed Manager - Subscribe, fetch, and process RSS feeds with content filtering and persistent storage
• 🖱️ Computer Tool - Automate desktop actions including mouse movements, keyboard input, screenshots, and application management

Important

The tools in this repository are experimental. Many of them grant agents powerful capabilities — executing code, accessing the file system, calling AWS APIs, connecting to external servers, and automating browsers and desktops — which carry real security implications. Any production use should be preceded by your own independent security review; see the Responsible AI guidance for best practices. Use of these tools is at your own risk.

📦 Installation

Quick Install

pip install strands-agents-tools

To install the dependencies for optional tools:

pip install "strands-agents-tools[mem0_memory, use_browser, rss, use_computer]"

Development Install

# Clone the repository
git clone https://github.com/strands-agents/tools.git
cd tools
# Create and activate virtual environment
python3 -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate# Install in development mode
pip install -e ".[dev]"# Install pre-commit hooks
pre-commit install

Tools Overview

Below is a comprehensive table of all available tools, how to use them with an agent, and typical use cases:

Tool	Agent Usage	Use Case
a2a_client	provider = A2AClientToolProvider(known_agent_urls=["http://localhost:9000"]); agent = Agent(tools=provider.tools)	Discover and communicate with A2A-compliant agents, send messages between agents
file_read	agent.tool.file_read(path="path/to/file.txt")	Reading configuration files, parsing code files, loading datasets
file_write	agent.tool.file_write(path="path/to/file.txt", content="file content")	Writing results to files, creating new files, saving output data
editor ⚠️	agent.tool.editor(command="view", path="path/to/file.py")	Advanced file operations like syntax highlighting, pattern replacement, and multi-file edits Deprecated — see Deprecations
shell* ⚠️	agent.tool.shell(command="ls -la")	Executing shell commands, interacting with the operating system, running scripts Deprecated — see Deprecations
http_request	agent.tool.http_request(method="GET", url="https://api.example.com/data")	Making API calls, fetching web data, sending data to external services
tavily_search	agent.tool.tavily_search(query="What is artificial intelligence?", search_depth="advanced")	Real-time web search optimized for AI agents with a variety of custom parameters
tavily_extract	agent.tool.tavily_extract(urls=["www.tavily.com"], extract_depth="advanced")	Extract clean, structured content from web pages with advanced processing and noise removal
tavily_crawl	agent.tool.tavily_crawl(url="www.tavily.com", max_depth=2, instructions="Find API docs")	Crawl websites intelligently starting from a base URL with filtering and extraction
tavily_map	agent.tool.tavily_map(url="www.tavily.com", max_depth=2, instructions="Find all pages")	Map website structure and discover URLs starting from a base URL without content extraction
exa_search	agent.tool.exa_search(query="Best project management tools", text=True)	Intelligent web search with auto mode (default) for optimal results, plus fast and deep search modes
exa_get_contents	agent.tool.exa_get_contents(urls=["https://example.com/article"], text=True, summary={"query": "key points"})	Extract full content and summaries from specific URLs with live crawling fallback
python_repl*	agent.tool.python_repl(code="import pandas as pd\ndf = pd.read_csv('data.csv')\nprint(df.head())")	Running Python code snippets, data analysis, executing complex logic with user confirmation for security
calculator ⚠️	agent.tool.calculator(expression="2 * sin(pi/4) + log(e**2)")	Performing mathematical operations, symbolic math, equation solving Deprecated — see Deprecations
code_interpreter	code_interpreter = AgentCoreCodeInterpreter(region="us-west-2"); agent = Agent(tools=[code_interpreter.code_interpreter])	Execute code in isolated sandbox environments with multi-language support (Python, JavaScript, TypeScript), persistent sessions, and file operations
use_aws	agent.tool.use_aws(service_name="s3", operation_name="list_buckets", parameters={}, region="us-west-2")	Interacting with AWS services, cloud resource management
retrieve ⚠️	agent.tool.retrieve(text="What is STRANDS?")	Retrieving information from Amazon Bedrock Knowledge Bases with optional metadata Deprecated — see Deprecations
nova_reels	agent.tool.nova_reels(action="create", text="A cinematic shot of mountains", s3_bucket="my-bucket")	Create high-quality videos using Amazon Bedrock Nova Reel with configurable parameters via environment variables
agent_core_memory	agent.tool.agent_core_memory(action="record", content="Hello, I like vegetarian food")	Store and retrieve memories with Amazon Bedrock Agent Core Memory service
mem0_memory	agent.tool.mem0_memory(action="store", content="Remember I like to play tennis")	Store user and agent memories across agent runs to provide personalized experience (tenant identity configured via Mem0MemoryTool or environment variables)
bright_data	agent.tool.bright_data(action="scrape_as_markdown", url="https://example.com")	Web scraping, search queries, screenshot capture, and structured data extraction from websites and different data feeds
memory ⚠️	agent.tool.memory(action="retrieve", query="product features")	Store, retrieve, list, and manage documents in Amazon Bedrock Knowledge Bases with configurable parameters via environment variables Deprecated — see Deprecations
environment ⚠️	agent.tool.environment(action="list", prefix="AWS_")	Managing environment variables, configuration management Deprecated — see Deprecations
generate_image_stability	agent.tool.generate_image_stability(prompt="A tranquil pool")	Creating images using Stability AI models
generate_image	agent.tool.generate_image(prompt="A sunset over mountains")	Creating AI-generated images for various applications
image_reader	agent.tool.image_reader(image_path="path/to/image.jpg")	Processing and reading image files for AI analysis
journal	agent.tool.journal(action="write", content="Today's progress notes")	Creating structured logs, maintaining documentation
think ⚠️	agent.tool.think(thought="Complex problem to analyze", cycle_count=3)	Advanced reasoning, multi-step thinking processes Deprecated — see Deprecations
load_tool	agent.tool.load_tool(path="path/to/custom_tool.py", name="custom_tool")	Dynamically loading custom tools and extensions
swarm	agent.tool.swarm(task="Analyze this problem", swarm_size=3, coordination_pattern="collaborative")	Coordinating multiple AI agents to solve complex problems through collective intelligence
current_time ⚠️	agent.tool.current_time(timezone="US/Pacific")	Get the current time in ISO 8601 format for a specified timezone Deprecated — see Deprecations
sleep ⚠️	agent.tool.sleep(seconds=5)	Pause execution for the specified number of seconds, interruptible with SIGINT (Ctrl+C) Deprecated — see Deprecations
agent_graph	agent.tool.agent_graph(agents=["agent1", "agent2"], connections=[{"from": "agent1", "to": "agent2"}])	Create and visualize agent relationship graphs for complex multi-agent systems
graph	agent.tool.graph(action="create", graph_id="pipeline", topology={"nodes": [...], "edges": [...]})	Create and manage deterministic DAG-based multi-agent graphs using Strands SDK Graph implementation with per-node model configuration
cron* ⚠️	agent.tool.cron(action="schedule", name="task", schedule="0 * * * *", command="backup.sh")	Schedule and manage recurring tasks with cron job syntax Does not work on Windows Deprecated — see Deprecations
slack ⚠️	agent.tool.slack(action="post_message", channel="general", text="Hello team!")	Interact with Slack workspace for messaging and monitoring Deprecated — see Deprecations
speak	agent.tool.speak(text="Operation completed successfully", style="green", mode="polly")	Output status messages with rich formatting and optional text-to-speech
stop	agent.tool.stop(message="Process terminated by user request")	Gracefully terminate agent execution with custom message
handoff_to_user	agent.tool.handoff_to_user(message="Please confirm action", breakout_of_loop=False)	Hand off control to user for confirmation, input, or complete task handoff
use_llm	agent.tool.use_llm(prompt="Analyze this data", system_prompt="You are a data analyst")	Create nested AI loops with customized system prompts for specialized tasks
use_agent	agent.tool.use_agent(prompt="Analyze this code", system_prompt="You are a code analyst.", model_provider="bedrock")	Create nested agent instances with model switching, multi-model workflows, cost optimization, and specialized sub-tasks
workflow	agent.tool.workflow(action="create", name="data_pipeline", steps=[{"tool": "file_read"}, {"tool": "python_repl"}])	Define, execute, and manage multi-step automated workflows
mcp_client	agent.tool.mcp_client(action="connect", connection_id="my_server", transport="stdio", command="python", args=["server.py"])	⚠️SECURITY WARNING: Dynamically connect to external MCP servers via stdio, sse, or streamable_http, list tools, and call remote tools. This can pose security risks as agents may connect to malicious servers. Use with caution in production.
batch ⚠️	agent.tool.batch(invocations=[{"name": "current_time", "arguments": {"timezone": "Europe/London"}}, {"name": "stop", "arguments": {}}])	Call multiple other tools from one request. Deprecated — see Deprecations
browser	browser = LocalChromiumBrowser(); agent = Agent(tools=[browser.browser])	Web scraping, automated testing, form filling, web automation tasks
diagram ⚠️	agent.tool.diagram(diagram_type="cloud", nodes=[{"id": "s3", "type": "S3"}], edges=[])	Create AWS cloud architecture diagrams, network diagrams, graphs, and UML diagrams (all 14 types) Deprecated — see Deprecations
rss ⚠️	agent.tool.rss(action="subscribe", url="https://example.com/feed.xml", feed_id="tech_news")	Manage RSS feeds: subscribe, fetch, read, search, and update content from various sources Deprecated — see Deprecations
use_computer	agent.tool.use_computer(action="click", x=100, y=200, app_name="Chrome")	Desktop automation, GUI interaction, screen capture
search_video	agent.tool.search_video(query="people discussing AI")	Semantic video search using TwelveLabs' Marengo model
chat_video	agent.tool.chat_video(prompt="What are the main topics?", video_id="video_123")	Interactive video analysis using TwelveLabs' Pegasus model
mongodb_memory	agent.tool.mongodb_memory(action="record", content="User prefers vegetarian pizza")	Store and retrieve memories using MongoDB Atlas with semantic search via AWS Bedrock Titan embeddings (connection and namespace configured via MongoDBMemoryTool or environment variables)
elasticsearch_memory	agent.tool.elasticsearch_memory(action="record", content="User prefers dark mode")	Store and retrieve memories using Elasticsearch with semantic search via AWS Bedrock Titan embeddings (connection and namespace configured via ElasticsearchMemoryTool or environment variables)

* These tools do not work on Windows

Deprecations

The tools below are deprecated, and each row points to where that capability now lives.

When this package started, the SDK had no built-in way to do most of these things, so we shipped tools to fill the gap. Much of that is now native: the SDK reasons, injects context, manages memory, and runs tools concurrently on its own, and where a vendor maintains an official MCP server, that server will always track their API better than a wrapper here can. Keeping a second implementation alongside means two things to fix and two things to drift, so we would rather point you at the one that gets the attention.

More tools will follow as their capabilities land elsewhere, and this repository will eventually be archived. Nothing breaks suddenly — but migrating when a tool is first deprecated is easier than moving several at once later.

Deprecated tools keep working. Each one logs a warning when invoked starting in v0.8.6, and that warning becomes an error log in v0.9.0 — a louder signal for anyone who has not migrated, not a behavior change.

They are also marked with @typing_extensions.deprecated, so type checkers and IDEs flag usage before you run anything. To list what you still need to migrate, run mypy --enable-error-code deprecated over your project: it reports the from strands_tools import ... line for each deprecated tool, without invoking any of them. Prefer mypy here: pyright, with reportDeprecated enabled, reports direct calls such as calculator(expression=...) but not agent.tool.calculator(...), and it reaches the import line for only the three tools whose marker is not wrapped by @tool. Note that Python suppresses the resulting DeprecationWarning at runtime when the agent invokes a tool, which is why the log message exists as well.

Tool	Suggested alternative	Warning	Error log
sleep	from strands.vended_tools import sleep	v0.8.6	v0.9.0
editor	from strands.vended_tools import file_editor	v0.8.6	v0.9.0
shell	from strands.vended_tools import bash	v0.8.6	v0.9.0
batch	none needed — concurrent tool execution is the SDK default (docs)	v0.8.6	v0.9.0
think	native extended thinking via model reasoning config (docs)	v0.8.6	v0.9.0
current_time	ContextInjector (docs)	v0.8.6	v0.9.0
memory	MemoryManager + BedrockKnowledgeBaseStore (docs)	v0.8.6	v0.9.0
retrieve	MemoryManager + BedrockKnowledgeBaseStore(writable=False) (docs)	v0.8.6	v0.9.0
calculator	from strands.vended_tools import bash (run python3 -c with sympy)	v0.8.6	v0.9.0
cron	from strands.vended_tools import bash (manage crontab), or Amazon EventBridge Scheduler	v0.8.6	v0.9.0
environment	from strands.vended_tools import bash (inspect only, see notes)	v0.8.6	v0.9.0
slack	official Slack MCP server; slack_bolt for Socket Mode	v0.8.6	v0.9.0
diagram	no replacement — have the model write graphviz/mermaid/diagrams code directly	v0.8.6	v0.9.0
rss	no replacement — parse feeds directly with feedparser	v0.8.6	v0.9.0

# BeforefromstrandsimportAgentfromstrands_toolsimporteditor, shell, sleepagent=Agent(tools=[editor, shell, sleep])
# AfterfromstrandsimportAgentfromstrands.vended_toolsimportbash, file_editor, sleepagent=Agent(tools=[bash, file_editor, sleep])

Behavior differences

The replacements are not drop-in equivalents. Check these before migrating:

• shell → bash: the SDK tool routes commands through the agent's configured sandbox and is stateless — each call runs in a fresh shell, so variables and the working directory do not persist between calls. It does not provide PTY support or batched parallel/sequential command execution.
• editor → file_editor: supports view, create, str_replace, and insert. The pattern_replace, find_line, and undo_edit commands have no SDK equivalent.
• sleep → sleep: the maximum duration is set with make_sleep(max_duration=...) and defaults to 60 seconds, replacing the MAX_SLEEP_SECONDS environment variable which defaulted to 300 seconds.
• batch — you can drop it. The SDK runs tool calls concurrently by default via ConcurrentToolExecutor, which also keeps tracing, metrics, and hooks intact. See Tool executors.
• think → extended thinking — reasoning is now a model capability rather than a tool, so you configure it once instead of prompting for it. It is single-pass, so if you were relying on cycle_count to refine across passes, or on tool calls inside the reasoning loop, that pattern moves into your own orchestration. Config is per provider — see Amazon Bedrock.
• current_time → ContextInjector — the date is context, not something the agent should have to ask for, so injecting it means it is always fresh and the model cannot forget to call it. The trade-off is that your code picks the timezone; if you need the model to choose one per call, the official MCP time server still does that. See ContextInjector.
• memory / retrieve → memory stores — memory is a first-class SDK concept now, so stores plug into the agent and inject context automatically instead of waiting to be called. store/retrieve become add/search. list, get, and delete are not part of the store protocol, so keep them as backend-native tools via get_tools(). One thing to know: the store returns relevance scores but does not filter on them, so if you relied on retrieve's default score >= 0.4 floor, apply it yourself. See Bedrock Knowledge Base store and Custom stores.
• calculator → shell — run python3 -c with sympy for the same symbolic math. Worth being explicit: shell runs whatever it is given, whereas this tool checked expressions against an allowlist first. If you are evaluating untrusted input, put a sandbox behind the shell tool or keep your own validation in front of it.
• cron → shell — crontab through the shell tool covers scheduling on a host. Two things to plan for: the shell is sandbox-routed, so under Docker or SSH your jobs land in an environment that may not have a cron daemon, and you will be composing crontab lines yourself rather than using structured list/add/remove/edit actions. For scheduling that outlives the host, Amazon EventBridge Scheduler is usually the better fit.
• environment → shell — env and printenv cover reading. Setting is genuinely different: a child shell cannot change the agent's own process environment, so variables need to be set where the agent is launched, or passed per call. If you were leaning on PROTECTED_VARS or secret masking, that guarding moves to your side.
• slack → Slack's official MCP server — Slack maintains it, so it tracks their API directly, and it uses OAuth rather than long-lived tokens. It exposes a curated tool set rather than this tool's passthrough to any Web API method, and being request/response it does not cover Socket Mode or real-time events — slack_bolt remains the right tool for event listeners. Endpoint and setup: docs.slack.dev/ai/mcp-server.
• diagram — no direct replacement, and that is deliberate: this tool was a wrapper over graphviz and the diagrams package, and a capable model writes that code well on its own. The wrapper mostly added a layer to keep in sync.
• rss — no direct replacement. Fetching and parsing a feed is a few lines of feedparser, and the subscription list was a JSON file. If you were using feed HTTP Basic auth or the stored subscriptions, those move into your code.

💻 Usage Examples

File Operations

fromstrandsimportAgentfromstrands_toolsimportfile_read, file_write, editoragent=Agent(tools=[file_read, file_write, editor])
agent.tool.file_read(path="config.json")
agent.tool.file_write(path="output.txt", content="Hello, world!")
agent.tool.editor(command="view", path="script.py")

Dynamic MCP Client Integration

⚠️SECURITY WARNING: The Dynamic MCP Client allows agents to autonomously connect to external MCP servers and load remote tools at runtime. This poses significant security risks as agents can potentially connect to malicious servers and execute untrusted code. Use with extreme caution in production environments.

This tool is different from the static MCP server implementation in the Strands SDK (see MCP Tools Documentation) which uses pre-configured, trusted MCP servers.

fromstrandsimportAgentfromstrands_toolsimportmcp_clientagent=Agent(tools=[mcp_client])
# Connect to a custom MCP server via stdioagent.tool.mcp_client(
action="connect",
connection_id="my_tools",
transport="stdio",
command="python",
args=["my_mcp_server.py"]
)
# List available tools on the servertools=agent.tool.mcp_client(
action="list_tools",
connection_id="my_tools"
)
# Call a tool from the MCP serverresult=agent.tool.mcp_client(
action="call_tool",
connection_id="my_tools",
tool_name="calculate",
tool_args={"x": 10, "y": 20}
)
# Connect to a SSE-based serveragent.tool.mcp_client(
action="connect",
connection_id="web_server",
transport="sse",
server_url="http://localhost:8080/sse"
)
# Connect to a streamable HTTP serveragent.tool.mcp_client(
action="connect",
connection_id="http_server",
transport="streamable_http",
server_url="https://api.example.com/mcp",
headers={"Authorization": "Bearer token"},
timeout=60
)
# Load MCP tools into agent's registry for direct access# ⚠️ WARNING: This loads external tools directly into the agentagent.tool.mcp_client(
action="load_tools",
connection_id="my_tools"
)
# Now you can call MCP tools directly as: agent.tool.calculate(x=10, y=20)

Shell Commands

Note: shell does not work on Windows.

fromstrandsimportAgentfromstrands_toolsimportshellagent=Agent(tools=[shell])
# Execute a single commandresult=agent.tool.shell(command="ls -la")
# Execute a sequence of commandsresults=agent.tool.shell(command=["mkdir -p test_dir", "cd test_dir", "touch test.txt"])
# Execute commands with error handlingagent.tool.shell(command="risky-command", ignore_errors=True)

HTTP Requests

fromstrandsimportAgentfromstrands_toolsimporthttp_requestagent=Agent(tools=[http_request])
# Make a simple GET requestresponse=agent.tool.http_request(
method="GET",
url="https://api.example.com/data"
)
# POST request with authenticationresponse=agent.tool.http_request(
method="POST",
url="https://api.example.com/resource",
headers={"Content-Type": "application/json"},
body=json.dumps({"key": "value"}),
auth_type="Bearer",
auth_token="your_token_here"
)
# Convert HTML webpages to markdown for better readabilityresponse=agent.tool.http_request(
method="GET",
url="https://example.com/article",
convert_to_markdown=True
)

Tavily Search, Extract, Crawl, and Map

fromstrandsimportAgentfromstrands_tools.tavilyimport (
tavily_search, tavily_extract, tavily_crawl, tavily_map
)
# For async usage, call the corresponding *_async function with await.# Synchronous usage agent=Agent(tools=[tavily_search, tavily_extract, tavily_crawl, tavily_map])
# Real-time web searchresult=agent.tool.tavily_search(
query="Latest developments in renewable energy",
search_depth="advanced",
topic="news",
max_results=10,
include_raw_content=True
)
# Extract content from multiple URLsresult=agent.tool.tavily_extract(
urls=["www.tavily.com", "www.apple.com"],
extract_depth="advanced",
format="markdown"
)
# Advanced crawl with instructions and filteringresult=agent.tool.tavily_crawl(
url="www.tavily.com",
max_depth=2,
limit=50,
instructions="Find all API documentation and developer guides",
extract_depth="advanced",
include_images=True
)
# Basic website mappingresult=agent.tool.tavily_map(url="www.tavily.com")

Exa Search and Contents

fromstrandsimportAgentfromstrands_tools.exaimportexa_search, exa_get_contentsagent=Agent(tools=[exa_search, exa_get_contents])
# Basic search (auto mode is default and recommended)result=agent.tool.exa_search(
query="Best project management software",
text=True
)
# Company-specific search when neededresult=agent.tool.exa_search(
query="Anthropic AI safety research",
category="company",
include_domains=["anthropic.com"],
num_results=5,
summary={"query": "key research areas and findings"}
)
# News search with date filteringresult=agent.tool.exa_search(
query="AI regulation policy updates",
category="news",
start_published_date="2024-01-01T00:00:00.000Z",
text=True
)
# Get detailed content from specific URLsresult=agent.tool.exa_get_contents(
urls=[
"https://example.com/blog-post",
"https://github.com/microsoft/semantic-kernel"
],
text={"maxCharacters": 5000, "includeHtmlTags": False},
summary={
"query": "main points and practical applications"
},
subpages=2,
extras={"links": 5, "imageLinks": 2}
)
# Structured summary with JSON schemaresult=agent.tool.exa_get_contents(
urls=["https://example.com/article"],
summary={
"query": "main findings and recommendations",
"schema": {
"type": "object",
"properties": {
"main_points": {"type": "string", "description": "Key points from the article"},
"recommendations": {"type": "string", "description": "Suggested actions or advice"},
"conclusion": {"type": "string", "description": "Overall conclusion"},
"relevance": {"type": "string", "description": "Why this matters"}
},
"required": ["main_points", "conclusion"]
}
}
)

Python Code Execution

Note: python_repl does not work on Windows.

fromstrandsimportAgentfromstrands_toolsimportpython_replagent=Agent(tools=[python_repl])
# Execute Python code with state persistenceresult=agent.tool.python_repl(code="""import pandas as pd# Load and process datadata = pd.read_csv('data.csv')processed = data.groupby('category').mean()processed.head()""")

Code Interpreter

fromstrandsimportAgentfromstrands_tools.code_interpreterimportAgentCoreCodeInterpreter# Create the code interpreter toolbedrock_agent_core_code_interpreter=AgentCoreCodeInterpreter(region="us-west-2")
agent=Agent(tools=[bedrock_agent_core_code_interpreter.code_interpreter])
# Create a sessionagent.tool.code_interpreter({
"action": {
"type": "initSession",
"description": "Data analysis session",
"session_name": "analysis-session"
}
})
# Execute Python codeagent.tool.code_interpreter({
"action": {
"type": "executeCode",
"session_name": "analysis-session",
"code": "print('Hello from sandbox!')",
"language": "python"
}
})

Swarm Intelligence

fromstrandsimportAgentfromstrands_toolsimportswarmagent=Agent(tools=[swarm])
# Create a collaborative swarm of agents to tackle a complex problemresult=agent.tool.swarm(
task="Generate creative solutions for reducing plastic waste in urban areas",
swarm_size=5,
coordination_pattern="collaborative"
)
# Create a competitive swarm for diverse solution generationresult=agent.tool.swarm(
task="Design an innovative product for smart home automation",
swarm_size=3,
coordination_pattern="competitive"
)
# Hybrid approach combining collaboration and competitionresult=agent.tool.swarm(
task="Develop marketing strategies for a new sustainable fashion brand",
swarm_size=4,
coordination_pattern="hybrid"
)

Use AWS

fromstrandsimportAgentfromstrands_toolsimportuse_awsagent=Agent(tools=[use_aws])
# List S3 bucketsresult=agent.tool.use_aws(
service_name="s3",
operation_name="list_buckets",
parameters={},
region="us-east-1",
label="List all S3 buckets"
)
# Get the contents of a specific S3 bucketresult=agent.tool.use_aws(
service_name="s3",
operation_name="list_objects_v2",
parameters={"Bucket": "example-bucket"}, # Replace with your actual bucket nameregion="us-east-1",
label="List objects in a specific S3 bucket"
)
# Get the list of EC2 subnetsresult=agent.tool.use_aws(
service_name="ec2",
operation_name="describe_subnets",
parameters={},
region="us-east-1",
label="List all subnets"
)

Retrieve Tool

fromstrandsimportAgentfromstrands_toolsimportretrieveagent=Agent(tools=[retrieve])
# Basic retrieval without metadataresult=agent.tool.retrieve(
text="What is artificial intelligence?"
)
# Retrieval with metadata enabledresult=agent.tool.retrieve(
text="What are the latest developments in machine learning?",
enableMetadata=True
)
# Using environment variable to set default metadata behavior# Set RETRIEVE_ENABLE_METADATA_DEFAULT=true in your environmentresult=agent.tool.retrieve(
text="Tell me about cloud computing"# enableMetadata will default to the environment variable value
)

Batch Tool

importosimportsysfromstrandsimportAgentfromstrands_toolsimportbatch, http_request, use_aws# Example usage of the batch with http_request and use_aws toolsagent=Agent(tools=[batch, http_request, use_aws])
result=agent.tool.batch(
invocations=[
{"name": "http_request", "arguments": {"method": "GET", "url": "https://api.ipify.org?format=json"}},
{
"name": "use_aws",
"arguments": {
"service_name": "s3",
"operation_name": "list_buckets",
"parameters": {},
"region": "us-east-1",
"label": "List S3 Buckets"
}
},
]
)

Video Tools

fromstrandsimportAgentfromstrands_toolsimportsearch_video, chat_videoagent=Agent(tools=[search_video, chat_video])
# Search for video content using natural languageresult=agent.tool.search_video(
query="people discussing AI technology",
threshold="high",
group_by="video",
page_limit=5
)
# Chat with existing video (no index_id needed)result=agent.tool.chat_video(
prompt="What are the main topics discussed in this video?",
video_id="existing-video-id"
)
# Chat with new video file (index_id required for upload)result=agent.tool.chat_video(
prompt="Describe what happens in this video",
video_path="/path/to/video.mp4",
index_id="your-index-id"# or set TWELVELABS_PEGASUS_INDEX_ID env var
)

AgentCore Memory

fromstrandsimportAgentfromstrands_tools.agent_core_memoryimportAgentCoreMemoryToolProviderprovider=AgentCoreMemoryToolProvider(
memory_id="memory-123abc", # Requiredactor_id="user-456", # Requiredsession_id="session-789", # Requirednamespace="default", # Requiredregion="us-west-2"# Optional, defaults to us-west-2
)
agent=Agent(tools=provider.tools)
# Create a new memoryresult=agent.tool.agent_core_memory(
action="record",
content="I am allergic to shellfish"
)
# Search for relevant memoriesresult=agent.tool.agent_core_memory(
action="retrieve",
query="user preferences"
)
# List all memoriesresult=agent.tool.agent_core_memory(
action="list"
)
# Get a specific memory by IDresult=agent.tool.agent_core_memory(
action="get",
memory_record_id="mr-12345"
)

Browser

fromstrandsimportAgentfromstrands_tools.browserimportLocalChromiumBrowser# Create browser toolbrowser=LocalChromiumBrowser()
agent=Agent(tools=[browser.browser])
# Simple navigationresult=agent.tool.browser({
"action": {
"type": "navigate",
"url": "https://example.com"
}
})
# Initialize a session firstresult=agent.tool.browser({
"action": {
"type": "initSession",
"session_name": "main-session",
"description": "Web automation session"
}
})

Handoff to User

fromstrandsimportAgentfromstrands_toolsimporthandoff_to_useragent=Agent(tools=[handoff_to_user])
# Request user confirmation and continueresponse=agent.tool.handoff_to_user(
message="I need your approval to proceed with deleting these files. Type 'yes' to confirm.",
breakout_of_loop=False
)
# Complete handoff to user (stops agent execution)agent.tool.handoff_to_user(
message="Task completed. Please review the results and take any necessary follow-up actions.",
breakout_of_loop=True
)

Use Agent (Agent as Tool)

fromstrandsimportAgentfromstrands_toolsimportuse_agentagent=Agent(tools=[use_agent])
# Basic usage - inherits parent agent's modelresult=agent.tool.use_agent(
prompt="Tell me about the advantages of tool-building in AI agents",
system_prompt="You are a helpful AI assistant specializing in AI development concepts."
)
# Use a different model provider for specialized tasksresult=agent.tool.use_agent(
prompt="Calculate 2 + 2 and explain the result",
system_prompt="You are a helpful math assistant.",
model_provider="bedrock",
model_settings={
"model_id": "us.anthropic.claude-sonnet-4-20250514-v1:0"
},
tools=["calculator"]
)
# Use environment variables to determine modelimportosos.environ["STRANDS_PROVIDER"] ="ollama"os.environ["STRANDS_MODEL_ID"] ="qwen3:4b"result=agent.tool.use_agent(
prompt="Analyze this code",
system_prompt="You are a code review assistant.",
model_provider="env"
)
# Custom model configuration with specific parametersresult=agent.tool.use_agent(
prompt="Write a creative story",
system_prompt="You are a creative writing assistant.",
model_provider="github",
model_settings={
"model_id": "openai/o4-mini",
"params": {"temperature": 1, "max_tokens": 4000}
}
)

A2A Client

fromstrandsimportAgentfromstrands_tools.a2a_clientimportA2AClientToolProvider# Initialize the A2A client provider with known agent URLsprovider=A2AClientToolProvider(known_agent_urls=["http://localhost:9000"])
agent=Agent(tools=provider.tools)
# Use natural language to interact with A2A agentsresponse=agent("discover available agents and send a greeting message")
# The agent will automatically use the available tools:# - discover_agent(url) to find agents# - list_discovered_agents() to see all discovered agents# - send_message(message_text, target_agent_url) to communicate

Diagram

fromstrandsimportAgentfromstrands_toolsimportdiagramagent=Agent(tools=[diagram])
# Create an AWS cloud architecture diagramresult=agent.tool.diagram(
diagram_type="cloud",
nodes=[
{"id": "users", "type": "Users", "label": "End Users"},
{"id": "cloudfront", "type": "CloudFront", "label": "CDN"},
{"id": "s3", "type": "S3", "label": "Static Assets"},
{"id": "api", "type": "APIGateway", "label": "API Gateway"},
{"id": "lambda", "type": "Lambda", "label": "Backend Service"}
],
edges=[
{"from": "users", "to": "cloudfront"},
{"from": "cloudfront", "to": "s3"},
{"from": "users", "to": "api"},
{"from": "api", "to": "lambda"}
],
title="Web Application Architecture"
)
# Create a UML class diagramresult=agent.tool.diagram(
diagram_type="class",
elements=[
{
"name": "User",
"attributes": ["+id: int", "-name: string", "#email: string"],
"methods": ["+login(): bool", "+logout(): void"]
},
{
"name": "Order",
"attributes": ["+id: int", "-items: List", "-total: float"],
"methods": ["+addItem(item): void", "+calculateTotal(): float"]
}
],
relationships=[
{"from": "User", "to": "Order", "type": "association", "multiplicity": "1..*"}
],
title="E-commerce Domain Model"
)

RSS Feed Management

fromstrandsimportAgentfromstrands_toolsimportrssagent=Agent(tools=[rss])
# Subscribe to a feedresult=agent.tool.rss(
action="subscribe",
url="https://news.example.com/rss/technology"
)
# List all subscribed feedsfeeds=agent.tool.rss(action="list")
# Read entries from a specific feedentries=agent.tool.rss(
action="read",
feed_id="news_example_com_technology",
max_entries=5,
include_content=True
)
# Search across all feedssearch_results=agent.tool.rss(
action="search",
query="machine learning",
max_entries=10
)
# Fetch feed content without subscribinglatest_news=agent.tool.rss(
action="fetch",
url="https://blog.example.org/feed",
max_entries=3
)

Use Computer

fromstrandsimportAgentfromstrands_toolsimportuse_computeragent=Agent(tools=[use_computer])
# Find mouse positionresult=agent.tool.use_computer(action="mouse_position")
# Automate adding textresult=agent.tool.use_computer(action="type", text="Hello, world!", app_name="Notepad")
# Analyze current computer screenresult=agent.tool.use_computer(action="analyze_screen")
result=agent.tool.use_computer(action="open_app", app_name="Calculator")
result=agent.tool.use_computer(action="close_app", app_name="Calendar")
result=agent.tool.use_computer(
action="hotkey",
hotkey_str="command+ctrl+f", # For macOSapp_name="Chrome"
)

Graph (Multi-Agent DAG)

Create deterministic DAG-based multi-agent pipelines where agents are nodes with dependency relationships. Unlike agent_graph (which uses persistent message-passing), graph uses task-based execution with output propagation.

fromstrandsimportAgentfromstrands_tools.graphimportgraphagent=Agent(tools=[graph])
# Create a multi-agent research pipelineresult=agent.tool.graph(
action="create",
graph_id="research_pipeline",
topology={
"nodes": [
{
"id": "researcher",
"role": "researcher",
"system_prompt": "You research topics thoroughly.",
"model_provider": "bedrock",
"model_settings": {"model_id": "us.anthropic.claude-sonnet-4-20250514-v1:0"}
},
{
"id": "analyst",
"role": "analyst",
"system_prompt": "You analyze research data.",
"model_provider": "bedrock",
"model_settings": {"model_id": "us.anthropic.claude-3-5-haiku-20241022-v1:0"}
},
{
"id": "reporter",
"role": "reporter",
"system_prompt": "You create comprehensive reports.",
"tools": ["file_write", "editor"]
}
],
"edges": [
{"from": "researcher", "to": "analyst"},
{"from": "analyst", "to": "reporter"}
],
"entry_points": ["researcher"]
}
)
# Execute a task through the graphresult=agent.tool.graph(
action="execute",
graph_id="research_pipeline",
task="Research and analyze the impact of AI on healthcare"
)
# Get graph statusresult=agent.tool.graph(action="status", graph_id="research_pipeline")
# List all graphsresult=agent.tool.graph(action="list")
# Delete a graphresult=agent.tool.graph(action="delete", graph_id="research_pipeline")

Elasticsearch Memory

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

fromstrandsimportAgentfromstrands_tools.elasticsearch_memoryimportElasticsearchMemoryTool, elasticsearch_memory# Bind connection, index, and namespace per principal (kept out of the agent-facing tool)memory_tool=ElasticsearchMemoryTool(
cloud_id="your-elasticsearch-cloud-id", # or es_url="https://...:443" for Serverlessapi_key="your-api-key",
index_name="memories",
namespace="user_123",
)
agent=Agent(tools=[memory_tool.elasticsearch_memory])
# Store a memory with semantic embeddingsresult=agent.tool.elasticsearch_memory(
action="record",
content="User prefers vegetarian pizza with extra cheese",
metadata={"category": "food_preferences", "type": "dietary"},
)
# Search memories using semantic similarity (vector search)result=agent.tool.elasticsearch_memory(
action="retrieve",
query="food preferences and dietary restrictions",
max_results=5,
)
# List all memories with paginationresult=agent.tool.elasticsearch_memory(action="list", max_results=10)
# Get specific memory by IDresult=agent.tool.elasticsearch_memory(action="get", memory_id="mem_1234567890_abcd1234")
# Delete a memoryresult=agent.tool.elasticsearch_memory(action="delete", memory_id="mem_1234567890_abcd1234")
# Single-tenant: use the standalone tool with configuration from environment variablesagent=Agent(tools=[elasticsearch_memory])
result=agent.tool.elasticsearch_memory(action="record", content="User prefers vegetarian pizza")

MongoDB Atlas Memory

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

fromstrandsimportAgentfromstrands_tools.mongodb_memoryimportMongoDBMemoryTool, mongodb_memory# Bind connection, collection, and namespace per principal (kept out of the agent-facing tool)memory_tool=MongoDBMemoryTool(
cluster_uri="mongodb+srv://username:password@cluster0.mongodb.net/?retryWrites=true&w=majority",
database_name="memories",
collection_name="user_memories",
namespace="user_123",
)
agent=Agent(tools=[memory_tool.mongodb_memory])
# Store a memory with semantic embeddingsresult=agent.tool.mongodb_memory(
action="record",
content="User prefers vegetarian pizza with extra cheese",
metadata={"category": "food_preferences", "type": "dietary"},
)
# Search memories using semantic similarity (vector search)result=agent.tool.mongodb_memory(
action="retrieve",
query="food preferences and dietary restrictions",
max_results=5,
)
# List all memories with paginationresult=agent.tool.mongodb_memory(action="list", max_results=10)
# Get specific memory by IDresult=agent.tool.mongodb_memory(action="get", memory_id="mem_1234567890_abcd1234")
# Delete a memoryresult=agent.tool.mongodb_memory(action="delete", memory_id="mem_1234567890_abcd1234")
# Single-tenant: use the standalone tool with configuration from environment variablesagent=Agent(tools=[mongodb_memory])
result=agent.tool.mongodb_memory(action="record", content="User prefers vegetarian pizza")

🌍 Environment Variables Configuration

Agents Tools provides extensive customization through environment variables. This allows you to configure tool behavior without modifying code, making it ideal for different environments (development, testing, production).

Global Environment Variables

These variables affect multiple tools:

Environment Variable	Description	Default	Affected Tools
BYPASS_TOOL_CONSENT	Bypass consent for tool invocation, set to "true" to enable	false	All tools that require consent (e.g. shell, file_write, python_repl)
STRANDS_NON_INTERACTIVE	Run tools without interactive prompts, set to "true" to suppress confirmation dialogs	false	Tools with a confirmation prompt (e.g. shell, python_repl)
STRANDS_TOOL_CONSOLE_MODE	Enable rich UI for tools, set to "enabled" to enable	disabled	All tools that have optional rich UI
AWS_REGION	Default AWS region for AWS operations	us-west-2	use_aws, retrieve, generate_image, memory, nova_reels
AWS_PROFILE	AWS profile name to use from ~/.aws/credentials	default	use_aws, retrieve
LOG_LEVEL	Logging level (DEBUG, INFO, WARNING, ERROR)	INFO	All tools

Tool-Specific Environment Variables

Calculator Tool

Environment Variable	Description	Default
CALCULATOR_MODE	Default calculation mode	evaluate
CALCULATOR_PRECISION	Number of decimal places for results	10
CALCULATOR_SCIENTIFIC	Whether to use scientific notation for numbers	False
CALCULATOR_FORCE_NUMERIC	Force numeric evaluation of symbolic expressions	False
CALCULATOR_FORCE_SCIENTIFIC_THRESHOLD	Threshold for automatic scientific notation	1e21
CALCULATOR_DERIVE_ORDER	Default order for derivatives	1
CALCULATOR_SERIES_POINT	Default point for series expansion	0
CALCULATOR_SERIES_ORDER	Default order for series expansion	5

Current Time Tool

Environment Variable	Description	Default
DEFAULT_TIMEZONE	Default timezone for current_time tool	UTC

Sleep Tool

Environment Variable	Description	Default
MAX_SLEEP_SECONDS	Maximum allowed sleep duration in seconds	300

Tavily Search, Extract, Crawl, and Map Tools

Environment Variable	Description	Default
TAVILY_API_KEY	Tavily API key (required for all Tavily functionality)	None

• Visit https://www.tavily.com/ to create a free account and API key.

Exa Search and Contents Tools

Environment Variable	Description	Default
EXA_API_KEY	Exa API key (required for all Exa functionality)	None

• Visit https://dashboard.exa.ai/api-keys to create a free account and API key.

Mem0 Memory Tool

Security Model: The tenant-isolation keys (user_id / agent_id) are never exposed as agent-facing tool parameters. The agent only chooses the action and its content/query/memory_id. This prevents a model (or prompt-injected content) from reading, writing, or deleting another tenant's memories.

Usage patterns:

fromstrandsimportAgentfromstrands_tools.mem0_memoryimportMem0MemoryTool, mem0_memory# Multi-tenant (recommended): bind identity per authenticated principaltool=Mem0MemoryTool(user_id=f"user_{authenticated_user_id}")
agent=Agent(tools=[tool.mem0_memory])
agent.tool.mem0_memory(action="store", content="User prefers vegetarian pizza")
# Single-tenant: use the standalone function with env vars (MEM0_USER_ID / MEM0_AGENT_ID)agent=Agent(tools=[mem0_memory])
agent.tool.mem0_memory(action="store", content="User prefers vegetarian pizza")

The Mem0 Memory Tool supports three different backend configurations:

1. Mem0 Platform:

   • Uses the Mem0 Platform API for memory management
   • Requires a Mem0 API key

2. OpenSearch (Recommended for AWS environments):

   • Uses OpenSearch as the vector store backend
   • Requires AWS credentials and OpenSearch configuration

3. FAISS (Default for local development):

   • Uses FAISS as the local vector store backend
   • Requires faiss-cpu package for local vector storage

4. Neptune Analytics (Optional Graph backend for search enhancement):

   • Uses Neptune Analytics as the graph store backend to enhance memory recall.
   • Requires AWS credentials and Neptune Analytics configuration

   # Configure your Neptune Analytics graph ID in the .env file:
   export NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER=sample-graph-id
   # Configure your Neptune Analytics graph ID in Python code:
   import os
   os.environ['NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER'] = "g-sample-graph-id"
   

Environment Variable	Description	Default	Required For
MEM0_USER_ID	User ID for memory operations (standalone function)	None	Standalone
MEM0_AGENT_ID	Agent ID for memory operations (standalone function)	None	Standalone
MEM0_API_KEY	Mem0 Platform API key	None	Mem0 Platform
OPENSEARCH_HOST	OpenSearch Host URL	None	OpenSearch
AWS_REGION	AWS Region for OpenSearch	us-west-2	OpenSearch
NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER	Neptune Analytics Graph Identifier	None	Neptune Analytics
DEV	Enable development mode (bypasses confirmations)	false	All modes
MEM0_LLM_PROVIDER	LLM provider for memory processing	aws_bedrock	All modes
MEM0_LLM_MODEL	LLM model for memory processing	anthropic.claude-3-5-haiku-20241022-v1:0	All modes
MEM0_LLM_TEMPERATURE	LLM temperature (0.0-2.0)	0.1	All modes
MEM0_LLM_MAX_TOKENS	LLM maximum tokens	2000	All modes
MEM0_EMBEDDER_PROVIDER	Embedder provider for vector embeddings	aws_bedrock	All modes
MEM0_EMBEDDER_MODEL	Embedder model for vector embeddings	amazon.titan-embed-text-v2:0	All modes

Note:

• If MEM0_API_KEY is set, the tool will use the Mem0 Platform
• If OPENSEARCH_HOST is set, the tool will use OpenSearch
• If neither is set, the tool will default to FAISS (requires faiss-cpu package)
• If NEPTUNE_ANALYTICS_GRAPH_IDENTIFIER is set, the tool will configure Neptune Analytics as graph store to enhance memory search
• LLM configuration applies to all backend modes and allows customization of the language model used for memory processing

Bright Data Tool

Environment Variable	Description	Default
BRIGHTDATA_API_KEY	Bright Data API Key	None
BRIGHTDATA_ZONE	Bright Data Web Unlocker Zone	web_unlocker1

Memory Tool

Environment Variable	Description	Default
MEMORY_DEFAULT_MAX_RESULTS	Default maximum results for list operations	50
MEMORY_DEFAULT_MIN_SCORE	Default minimum relevance score for filtering results	0.4

Nova Reels Tool

Environment Variable	Description	Default
NOVA_REEL_DEFAULT_SEED	Default seed for video generation	0
NOVA_REEL_DEFAULT_FPS	Default frames per second for generated videos	24
NOVA_REEL_DEFAULT_DIMENSION	Default video resolution in WIDTHxHEIGHT format	1280x720
NOVA_REEL_DEFAULT_MAX_RESULTS	Default maximum number of jobs to return for list action	10

Python REPL Tool

Environment Variable	Description	Default
PYTHON_REPL_BINARY_MAX_LEN	Maximum length for binary content before truncation	100
PYTHON_REPL_INTERACTIVE	Whether to enable interactive PTY mode	None
PYTHON_REPL_RESET_STATE	Whether to reset the REPL state before execution	None
PYTHON_REPL_PERSISTENCE_DIR	Set Directory for python_repl tool to write state file	None

Shell Tool

Environment Variable	Description	Default
SHELL_DEFAULT_TIMEOUT	Default timeout in seconds for shell commands	900

Slack Tool

Environment Variable	Description	Default
SLACK_DEFAULT_EVENT_COUNT	Default number of events to retrieve	42
STRANDS_SLACK_AUTO_REPLY	Enable automatic replies to messages	false
STRANDS_SLACK_LISTEN_ONLY_TAG	Only process messages containing this tag	None

Speak Tool

Environment Variable	Description	Default
SPEAK_DEFAULT_STYLE	Default style for status messages	green
SPEAK_DEFAULT_MODE	Default speech mode (fast/polly)	fast
SPEAK_DEFAULT_VOICE_ID	Default Polly voice ID	Joanna
SPEAK_DEFAULT_OUTPUT_PATH	Default audio output path	speech_output.mp3
SPEAK_DEFAULT_PLAY_AUDIO	Whether to play audio by default	True

Editor Tool

Environment Variable	Description	Default
EDITOR_DIR_TREE_MAX_DEPTH	Maximum depth for directory tree visualization	2
EDITOR_DEFAULT_STYLE	Default style for output panels	default
EDITOR_DEFAULT_LANGUAGE	Default language for syntax highlighting	python
EDITOR_DISABLE_BACKUP	Skip creating .bak backup files during edit operations	false

Environment Tool

Environment Variable	Description	Default
ENV_VARS_MASKED_DEFAULT	Masking of values whose name contains TOKEN, SECRET, PASSWORD, KEY, or AUTH. Set to false to disable. This is the only way to configure masking: the agent cannot override it through tool input, and the environment tool cannot set it. Tools that execute arbitrary code in the agent process, such as python_repl and shell, can still write it	true

HTTP Request Tool

Environment Variable	Description	Default
STRANDS_HTTP_ALLOW_INSECURE_SSL	Allow disabling SSL certificate verification via verify_ssl parameter	false

Dynamic MCP Client Tool

Environment Variable	Description	Default
STRANDS_MCP_TIMEOUT	Default timeout in seconds for MCP operations	30.0

File Read Tool

Environment Variable	Description	Default
FILE_READ_RECURSIVE_DEFAULT	Default setting for recursive file searching	true
FILE_READ_CONTEXT_LINES_DEFAULT	Default number of context lines around search matches	2
FILE_READ_START_LINE_DEFAULT	Default starting line number for lines mode	0
FILE_READ_CHUNK_OFFSET_DEFAULT	Default byte offset for chunk mode	0
FILE_READ_DIFF_TYPE_DEFAULT	Default diff type for file comparisons	unified
FILE_READ_USE_GIT_DEFAULT	Default setting for using git in time machine mode	true
FILE_READ_NUM_REVISIONS_DEFAULT	Default number of revisions to show in time machine mode	5

Browser Tool

Environment Variable	Description	Default
STRANDS_DEFAULT_WAIT_TIME	Default setting for wait time with actions	1
STRANDS_BROWSER_MAX_RETRIES	Default number of retries to perform when an action fails	3
STRANDS_BROWSER_RETRY_DELAY	Default retry delay time for retry mechanisms	1
STRANDS_BROWSER_SCREENSHOTS_DIR	Default directory where screenshots will be saved	screenshots
STRANDS_BROWSER_USER_DATA_DIR	Default directory where data for reloading a browser instance is stored	~/.browser_automation
STRANDS_BROWSER_HEADLESS	Default headless setting for launching browsers	false
STRANDS_BROWSER_WIDTH	Default width of the browser	1280
STRANDS_BROWSER_HEIGHT	Default height of the browser	800

RSS Tool

Environment Variable	Description	Default
STRANDS_RSS_MAX_ENTRIES	Default setting for maximum number of entries per feed	100
STRANDS_RSS_UPDATE_INTERVAL	Default amount of time between updating rss feeds in minutes	60
STRANDS_RSS_STORAGE_PATH	Default storage path where rss feeds are stored locally	strands_rss_feeds (this may vary based on your system)

Retrieve Tool

Environment Variable	Description	Default
RETRIEVE_ENABLE_METADATA_DEFAULT	Default setting for enabling metadata in retrieve tool responses	false

Use Agent Tool

Environment Variable	Description	Default
STRANDS_PROVIDER	Default model provider when using model_provider="env"	ollama
STRANDS_MODEL_ID	Default model identifier for environment-based model selection	None
STRANDS_MAX_TOKENS	Maximum tokens for the nested agent model	None
STRANDS_TEMPERATURE	Sampling temperature for the nested agent model	None

Elasticsearch Memory Tool

Environment Variable	Description	Default
ELASTICSEARCH_CLOUD_ID	Elasticsearch Cloud ID for connection	None
ELASTICSEARCH_URL	Elasticsearch URL for serverless connection	None
ELASTICSEARCH_API_KEY	Elasticsearch API key for authentication	None
ELASTICSEARCH_INDEX_NAME	Elasticsearch index name for memory storage	strands_memory
ELASTICSEARCH_NAMESPACE	Namespace for memory isolation	default
ELASTICSEARCH_EMBEDDING_MODEL	Amazon Bedrock model for embeddings	amazon.titan-embed-text-v2:0
AWS_REGION	AWS region for Bedrock embedding service	us-west-2

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

Graph Tool

The graph tool uses the same model provider environment variables as use_agent for per-node model configuration. No additional environment variables are required.

Video Tools

Environment Variable	Description	Default
TWELVELABS_API_KEY	TwelveLabs API key for video analysis	None
TWELVELABS_MARENGO_INDEX_ID	Default index ID for search_video tool	None
TWELVELABS_PEGASUS_INDEX_ID	Default index ID for chat_video tool	None

MongoDB Atlas Memory Tool

Environment Variable	Description	Default
MONGODB_ATLAS_CLUSTER_URI	MongoDB Atlas connection string	None
MONGODB_DATABASE_NAME	Database name for MongoDB operations	strands_memory
MONGODB_COLLECTION_NAME	Collection name for MongoDB operations	memories
MONGODB_NAMESPACE	Namespace for memory isolation	default
MONGODB_EMBEDDING_MODEL	Amazon Bedrock model for embeddings	amazon.titan-embed-text-v2:0

Note: This tool requires AWS account credentials to generate embeddings using Amazon Bedrock Titan models.

Contributing ❤️

This is a community-driven project, powered by passionate developers like you. We enthusiastically welcome contributions from everyone, regardless of experience level—your unique perspective is valuable to us!

How to Get Started?

1. Find your first opportunity: If you're new to the project, explore our labeled "good first issues" for beginner-friendly tasks.
2. Understand our workflow: Review our Contributing Guide to learn about our development setup, coding standards, and pull request process.
3. Make your impact: Contributions come in many forms—fixing bugs, enhancing documentation, improving performance, adding features, writing tests, or refining the user experience.
4. Submit your work: When you're ready, submit a well-documented pull request, and our maintainers will provide feedback to help get your changes merged.

Your questions, insights, and ideas are always welcome!

Together, we're building something meaningful that impacts real users. We look forward to collaborating with you!

Stay in touch with the team

Come meet the Strands team and other users on Discord

License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Security

The tools in this repository are experimental and are provided as-is. Any production use should be preceded by an independent security review of the specific tools you enable.

For guidance on building and deploying agents safely, see Responsible AI in the Strands Agents documentation.

To report a security issue, see CONTRIBUTING for more information.