Agent
¶
Swarm Agent is a powerful autonomous agent framework designed to connect Language Models (LLMs) with various tools and long-term memory. This class provides the ability to ingest and process various types of documents such as PDFs, text files, Markdown files, JSON files, and more. The Agent structure offers a wide range of features to enhance the capabilities of LLMs and facilitate efficient task execution.
Overview¶
The Agent
class establishes a conversational loop with a language model, allowing for interactive task execution, feedback collection, and dynamic response generation. It includes features such as:
- Conversational Loop: Enables back-and-forth interaction with the model.
- Feedback Collection: Allows users to provide feedback on generated responses.
- Stoppable Conversation: Supports custom stopping conditions for the conversation.
- Retry Mechanism: Implements a retry system for handling issues in response generation.
- Tool Integration: Supports the integration of various tools for enhanced capabilities.
- Long-term Memory Management: Incorporates vector databases for efficient information retrieval.
- Document Ingestion: Processes various document types for information extraction.
- Interactive Mode: Allows real-time communication with the agent.
- Sentiment Analysis: Evaluates the sentiment of generated responses.
- Output Filtering and Cleaning: Ensures generated responses meet specific criteria.
- Asynchronous and Concurrent Execution: Supports efficient parallelization of tasks.
- Planning and Reasoning: Implements techniques like algorithm of thoughts for enhanced decision-making.
Architecture¶
graph TD
A[Task Initiation] -->|Receives Task| B[Initial LLM Processing]
B -->|Interprets Task| C[Tool Usage]
C -->|Calls Tools| D[Function 1]
C -->|Calls Tools| E[Function 2]
D -->|Returns Data| C
E -->|Returns Data| C
C -->|Provides Data| F[Memory Interaction]
F -->|Stores and Retrieves Data| G[RAG System]
G -->|ChromaDB/Pinecone| H[Enhanced Data]
F -->|Provides Enhanced Data| I[Final LLM Processing]
I -->|Generates Final Response| J[Output]
C -->|No Tools Available| K[Skip Tool Usage]
K -->|Proceeds to Memory Interaction| F
F -->|No Memory Available| L[Skip Memory Interaction]
L -->|Proceeds to Final LLM Processing| I
Agent
Attributes¶
Attribute | Description |
---|---|
id |
Unique identifier for the agent instance. |
llm |
Language model instance used by the agent. |
template |
Template used for formatting responses. |
max_loops |
Maximum number of loops the agent can run. |
stopping_condition |
Callable function determining when to stop looping. |
loop_interval |
Interval (in seconds) between loops. |
retry_attempts |
Number of retry attempts for failed LLM calls. |
retry_interval |
Interval (in seconds) between retry attempts. |
return_history |
Boolean indicating whether to return conversation history. |
stopping_token |
Token that stops the agent from looping when present in the response. |
dynamic_loops |
Boolean indicating whether to dynamically determine the number of loops. |
interactive |
Boolean indicating whether to run in interactive mode. |
dashboard |
Boolean indicating whether to display a dashboard. |
agent_name |
Name of the agent instance. |
agent_description |
Description of the agent instance. |
system_prompt |
System prompt used to initialize the conversation. |
tools |
List of callable functions representing tools the agent can use. |
dynamic_temperature_enabled |
Boolean indicating whether to dynamically adjust the LLM's temperature. |
sop |
Standard operating procedure for the agent. |
sop_list |
List of strings representing the standard operating procedure. |
saved_state_path |
File path for saving and loading the agent's state. |
autosave |
Boolean indicating whether to automatically save the agent's state. |
context_length |
Maximum length of the context window (in tokens) for the LLM. |
user_name |
Name used to represent the user in the conversation. |
self_healing_enabled |
Boolean indicating whether to attempt self-healing in case of errors. |
code_interpreter |
Boolean indicating whether to interpret and execute code snippets. |
multi_modal |
Boolean indicating whether to support multimodal inputs. |
pdf_path |
File path of a PDF document to be ingested. |
list_of_pdf |
List of file paths for PDF documents to be ingested. |
tokenizer |
Instance of a tokenizer used for token counting and management. |
long_term_memory |
Instance of a BaseVectorDatabase implementation for long-term memory management. |
preset_stopping_token |
Boolean indicating whether to use a preset stopping token. |
traceback |
Object used for traceback handling. |
traceback_handlers |
List of traceback handlers. |
streaming_on |
Boolean indicating whether to stream responses. |
docs |
List of document paths or contents to be ingested. |
docs_folder |
Path to a folder containing documents to be ingested. |
verbose |
Boolean indicating whether to print verbose output. |
parser |
Callable function used for parsing input data. |
best_of_n |
Integer indicating the number of best responses to generate. |
callback |
Callable function to be called after each agent loop. |
metadata |
Dictionary containing metadata for the agent. |
callbacks |
List of callable functions to be called during execution. |
logger_handler |
Handler for logging messages. |
search_algorithm |
Callable function for long-term memory retrieval. |
logs_to_filename |
File path for logging agent activities. |
evaluator |
Callable function for evaluating the agent's responses. |
stopping_func |
Callable function used as a stopping condition. |
custom_loop_condition |
Callable function used as a custom loop condition. |
sentiment_threshold |
Float value representing the sentiment threshold for evaluating responses. |
custom_exit_command |
String representing a custom command for exiting the agent's loop. |
sentiment_analyzer |
Callable function for sentiment analysis on outputs. |
limit_tokens_from_string |
Callable function for limiting the number of tokens in a string. |
custom_tools_prompt |
Callable function for generating a custom prompt for tool usage. |
tool_schema |
Data structure representing the schema for the agent's tools. |
output_type |
Type representing the expected output type of responses. |
function_calling_type |
String representing the type of function calling. |
output_cleaner |
Callable function for cleaning the agent's output. |
function_calling_format_type |
String representing the format type for function calling. |
list_base_models |
List of base models used for generating tool schemas. |
metadata_output_type |
String representing the output type for metadata. |
state_save_file_type |
String representing the file type for saving the agent's state. |
chain_of_thoughts |
Boolean indicating whether to use the chain of thoughts technique. |
algorithm_of_thoughts |
Boolean indicating whether to use the algorithm of thoughts technique. |
tree_of_thoughts |
Boolean indicating whether to use the tree of thoughts technique. |
tool_choice |
String representing the method for tool selection. |
execute_tool |
Boolean indicating whether to execute tools. |
rules |
String representing the rules for the agent's behavior. |
planning |
Boolean indicating whether to perform planning. |
planning_prompt |
String representing the prompt for planning. |
device |
String representing the device on which the agent should run. |
custom_planning_prompt |
String representing a custom prompt for planning. |
memory_chunk_size |
Integer representing the maximum size of memory chunks for long-term memory retrieval. |
agent_ops_on |
Boolean indicating whether agent operations should be enabled. |
return_step_meta |
Boolean indicating whether to return JSON of all steps and additional metadata. |
output_type |
Literal type indicating whether to output "string", "str", "list", "json", "dict", or "yaml". |
time_created |
Float representing the time the agent was created. |
tags |
Optional list of strings for tagging the agent. |
use_cases |
Optional list of dictionaries describing use cases for the agent. |
step_pool |
List of Step objects representing the agent's execution steps. |
print_every_step |
Boolean indicating whether to print every step of execution. |
agent_output |
ManySteps object containing the agent's output and metadata. |
executor_workers |
Integer representing the number of executor workers for concurrent operations. |
data_memory |
Optional callable for data memory operations. |
load_yaml_path |
String representing the path to a YAML file for loading configurations. |
auto_generate_prompt |
Boolean indicating whether to automatically generate prompts. |
rag_every_loop |
Boolean indicating whether to query RAG database for context on every loop |
plan_enabled |
Boolean indicating whether planning functionality is enabled |
artifacts_on |
Boolean indicating whether to save artifacts from agent execution |
artifacts_output_path |
File path where artifacts should be saved |
artifacts_file_extension |
File extension to use for saved artifacts |
device |
Device to run computations on ("cpu" or "gpu") |
all_cores |
Boolean indicating whether to use all CPU cores |
device_id |
ID of the GPU device to use if running on GPU |
scheduled_run_date |
Optional datetime for scheduling future agent runs |
Agent
Methods¶
Method | Description | Inputs | Usage Example |
---|---|---|---|
run(task, img=None, is_last=False, device="cpu", device_id=0, all_cores=True, *args, **kwargs) |
Runs the autonomous agent loop to complete the given task. | task (str): The task to be performed.img (str, optional): Path to an image file.is_last (bool): Whether this is the last task.device (str): Device to run on ("cpu" or "gpu").device_id (int): ID of the GPU to use.all_cores (bool): Whether to use all CPU cores.*args , **kwargs : Additional arguments. |
response = agent.run("Generate a report on financial performance.") |
__call__(task, img=None, *args, **kwargs) |
Alternative way to call the run method. |
Same as run . |
response = agent("Generate a report on financial performance.") |
parse_and_execute_tools(response, *args, **kwargs) |
Parses the agent's response and executes any tools mentioned in it. | response (str): The agent's response to be parsed.*args , **kwargs : Additional arguments. |
agent.parse_and_execute_tools(response) |
add_memory(message) |
Adds a message to the agent's memory. | message (str): The message to add. |
agent.add_memory("Important information") |
plan(task, *args, **kwargs) |
Plans the execution of a task. | task (str): The task to plan.*args , **kwargs : Additional arguments. |
agent.plan("Analyze market trends") |
run_concurrent(task, *args, **kwargs) |
Runs a task concurrently. | task (str): The task to run.*args , **kwargs : Additional arguments. |
response = await agent.run_concurrent("Concurrent task") |
run_concurrent_tasks(tasks, *args, **kwargs) |
Runs multiple tasks concurrently. | tasks (List[str]): List of tasks to run.*args , **kwargs : Additional arguments. |
responses = agent.run_concurrent_tasks(["Task 1", "Task 2"]) |
bulk_run(inputs) |
Generates responses for multiple input sets. | inputs (List[Dict[str, Any]]): List of input dictionaries. |
responses = agent.bulk_run([{"task": "Task 1"}, {"task": "Task 2"}]) |
save() |
Saves the agent's history to a file. | None | agent.save() |
load(file_path) |
Loads the agent's history from a file. | file_path (str): Path to the file. |
agent.load("agent_history.json") |
graceful_shutdown() |
Gracefully shuts down the system, saving the state. | None | agent.graceful_shutdown() |
analyze_feedback() |
Analyzes the feedback for issues. | None | agent.analyze_feedback() |
undo_last() |
Undoes the last response and returns the previous state. | None | previous_state, message = agent.undo_last() |
add_response_filter(filter_word) |
Adds a response filter to filter out certain words. | filter_word (str): Word to filter. |
agent.add_response_filter("sensitive") |
apply_response_filters(response) |
Applies response filters to the given response. | response (str): Response to filter. |
filtered_response = agent.apply_response_filters(response) |
filtered_run(task) |
Runs a task with response filtering applied. | task (str): Task to run. |
response = agent.filtered_run("Generate a report") |
save_to_yaml(file_path) |
Saves the agent to a YAML file. | file_path (str): Path to save the YAML file. |
agent.save_to_yaml("agent_config.yaml") |
get_llm_parameters() |
Returns the parameters of the language model. | None | llm_params = agent.get_llm_parameters() |
save_state(file_path, *args, **kwargs) |
Saves the current state of the agent to a JSON file. | file_path (str): Path to save the JSON file.*args , **kwargs : Additional arguments. |
agent.save_state("agent_state.json") |
update_system_prompt(system_prompt) |
Updates the system prompt. | system_prompt (str): New system prompt. |
agent.update_system_prompt("New system instructions") |
update_max_loops(max_loops) |
Updates the maximum number of loops. | max_loops (int): New maximum number of loops. |
agent.update_max_loops(5) |
update_loop_interval(loop_interval) |
Updates the loop interval. | loop_interval (int): New loop interval. |
agent.update_loop_interval(2) |
update_retry_attempts(retry_attempts) |
Updates the number of retry attempts. | retry_attempts (int): New number of retry attempts. |
agent.update_retry_attempts(3) |
update_retry_interval(retry_interval) |
Updates the retry interval. | retry_interval (int): New retry interval. |
agent.update_retry_interval(5) |
reset() |
Resets the agent's memory. | None | agent.reset() |
ingest_docs(docs, *args, **kwargs) |
Ingests documents into the agent's memory. | docs (List[str]): List of document paths.*args , **kwargs : Additional arguments. |
agent.ingest_docs(["doc1.pdf", "doc2.txt"]) |
ingest_pdf(pdf) |
Ingests a PDF document into the agent's memory. | pdf (str): Path to the PDF file. |
agent.ingest_pdf("document.pdf") |
receive_message(name, message) |
Receives a message and adds it to the agent's memory. | name (str): Name of the sender.message (str): Content of the message. |
agent.receive_message("User", "Hello, agent!") |
send_agent_message(agent_name, message, *args, **kwargs) |
Sends a message from the agent to a user. | agent_name (str): Name of the agent.message (str): Message to send.*args , **kwargs : Additional arguments. |
response = agent.send_agent_message("AgentX", "Task completed") |
add_tool(tool) |
Adds a tool to the agent's toolset. | tool (Callable): Tool to add. |
agent.add_tool(my_custom_tool) |
add_tools(tools) |
Adds multiple tools to the agent's toolset. | tools (List[Callable]): List of tools to add. |
agent.add_tools([tool1, tool2]) |
remove_tool(tool) |
Removes a tool from the agent's toolset. | Method | |
-------- | ------------- | -------- | ---------------- |
remove_tool(tool) |
Removes a tool from the agent's toolset. | tool (Callable): Tool to remove. |
agent.remove_tool(my_custom_tool) |
remove_tools(tools) |
Removes multiple tools from the agent's toolset. | tools (List[Callable]): List of tools to remove. |
agent.remove_tools([tool1, tool2]) |
get_docs_from_doc_folders() |
Retrieves and processes documents from the specified folder. | None | agent.get_docs_from_doc_folders() |
check_end_session_agentops() |
Checks and ends the AgentOps session if enabled. | None | agent.check_end_session_agentops() |
memory_query(task, *args, **kwargs) |
Queries the long-term memory for relevant information. | task (str): The task or query.*args , **kwargs : Additional arguments. |
result = agent.memory_query("Find information about X") |
sentiment_analysis_handler(response) |
Performs sentiment analysis on the given response. | response (str): The response to analyze. |
agent.sentiment_analysis_handler("Great job!") |
count_and_shorten_context_window(history, *args, **kwargs) |
Counts tokens and shortens the context window if necessary. | history (str): The conversation history.*args , **kwargs : Additional arguments. |
shortened_history = agent.count_and_shorten_context_window(history) |
output_cleaner_and_output_type(response, *args, **kwargs) |
Cleans and formats the output based on specified type. | response (str): The response to clean and format.*args , **kwargs : Additional arguments. |
cleaned_response = agent.output_cleaner_and_output_type(response) |
stream_response(response, delay=0.001) |
Streams the response token by token. | response (str): The response to stream.delay (float): Delay between tokens. |
agent.stream_response("This is a streamed response") |
dynamic_context_window() |
Dynamically adjusts the context window. | None | agent.dynamic_context_window() |
check_available_tokens() |
Checks and returns the number of available tokens. | None | available_tokens = agent.check_available_tokens() |
tokens_checks() |
Performs token checks and returns available tokens. | None | token_info = agent.tokens_checks() |
truncate_string_by_tokens(input_string, limit) |
Truncates a string to fit within a token limit. | input_string (str): String to truncate.limit (int): Token limit. |
truncated_string = agent.truncate_string_by_tokens("Long string", 100) |
tokens_operations(input_string) |
Performs various token-related operations on the input string. | input_string (str): String to process. |
processed_string = agent.tokens_operations("Input string") |
parse_function_call_and_execute(response) |
Parses a function call from the response and executes it. | response (str): Response containing the function call. |
result = agent.parse_function_call_and_execute(response) |
activate_agentops() |
Activates AgentOps functionality. | None | agent.activate_agentops() |
llm_output_parser(response) |
Parses the output from the language model. | response (Any): Response from the LLM. |
parsed_response = agent.llm_output_parser(llm_output) |
log_step_metadata(loop, task, response) |
Logs metadata for each step of the agent's execution. | loop (int): Current loop number.task (str): Current task.response (str): Agent's response. |
agent.log_step_metadata(1, "Analyze data", "Analysis complete") |
to_dict() |
Converts the agent's attributes to a dictionary. | None | agent_dict = agent.to_dict() |
to_json(indent=4, *args, **kwargs) |
Converts the agent's attributes to a JSON string. | indent (int): Indentation for JSON.*args , **kwargs : Additional arguments. |
agent_json = agent.to_json() |
to_yaml(indent=4, *args, **kwargs) |
Converts the agent's attributes to a YAML string. | indent (int): Indentation for YAML.*args , **kwargs : Additional arguments. |
agent_yaml = agent.to_yaml() |
to_toml(*args, **kwargs) |
Converts the agent's attributes to a TOML string. | *args , **kwargs : Additional arguments. |
agent_toml = agent.to_toml() |
model_dump_json() |
Saves the agent model to a JSON file in the workspace directory. | None | agent.model_dump_json() |
model_dump_yaml() |
Saves the agent model to a YAML file in the workspace directory. | None | agent.model_dump_yaml() |
log_agent_data() |
Logs the agent's data to an external API. | None | agent.log_agent_data() |
handle_tool_schema_ops() |
Handles operations related to tool schemas. | None | agent.handle_tool_schema_ops() |
call_llm(task, *args, **kwargs) |
Calls the appropriate method on the language model. | task (str): Task for the LLM.*args , **kwargs : Additional arguments. |
response = agent.call_llm("Generate text") |
handle_sop_ops() |
Handles operations related to standard operating procedures. | None | agent.handle_sop_ops() |
agent_output_type(responses) |
Processes and returns the agent's output based on the specified output type. | responses (list): List of responses. |
formatted_output = agent.agent_output_type(responses) |
check_if_no_prompt_then_autogenerate(task) |
Checks if a system prompt is not set and auto-generates one if needed. | task (str): The task to use for generating a prompt. |
agent.check_if_no_prompt_then_autogenerate("Analyze data") |
check_if_no_prompt_then_autogenerate(task) |
Checks if auto_generate_prompt is enabled and generates a prompt by combining agent name, description and system prompt | task (str, optional): Task to use as fallback |
agent.check_if_no_prompt_then_autogenerate("Analyze data") |
handle_artifacts(response, output_path, extension) |
Handles saving artifacts from agent execution | response (str): Agent responseoutput_path (str): Output pathextension (str): File extension |
agent.handle_artifacts(response, "outputs/", ".txt") |
Updated Run Method¶
Update the run method documentation to include new parameters:
Method | Description | Inputs | Usage Example |
---|---|---|---|
run(task, img=None, is_last=False, device="cpu", device_id=0, all_cores=True, scheduled_run_date=None) |
Runs the agent with specified parameters | task (str): Task to runimg (str, optional): Image pathis_last (bool): If this is last taskdevice (str): Device to usedevice_id (int): GPU IDall_cores (bool): Use all CPU coresscheduled_run_date (datetime, optional): Future run date |
agent.run("Analyze data", device="gpu", device_id=0) |
Getting Started¶
To use the Swarm Agent, first install the required dependencies:
Then, you can initialize and use the agent as follows:
import os
from swarms import Agent
from swarm_models import OpenAIChat
from swarms.prompts.finance_agent_sys_prompt import FINANCIAL_AGENT_SYS_PROMPT
# Get the OpenAI API key from the environment variable
api_key = os.getenv("OPENAI_API_KEY")
# Create an instance of the OpenAIChat class
model = OpenAIChat(
api_key=api_key, model_name="gpt-4-0613", temperature=0.1
)
# Initialize the agent
agent = Agent(
agent_name="Financial-Analysis-Agent",
system_prompt=FINANCIAL_AGENT_SYS_PROMPT,
llm=model,
max_loops=1,
autosave=True,
dashboard=False,
verbose=True,
dynamic_temperature_enabled=True,
saved_state_path="finance_agent.json",
user_name="swarms_corp",
retry_attempts=1,
context_length=200000,
return_step_meta=False,
output_type="str",
)
# Run the agent
response = agent.run(
"How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria?"
)
print(response)
Advanced Usage¶
Tool Integration¶
To integrate tools with the Swarm Agent
, you can pass a list of callable functions with types and doc strings to the tools
parameter when initializing the Agent
instance. The agent will automatically convert these functions into an OpenAI function calling schema and make them available for use during task execution.
Requirements for a tool¶
- Function
- With types
- with doc strings
from swarms import Agent
from swarm_models import OpenAIChat
import subprocess
def terminal(code: str):
"""
Run code in the terminal.
Args:
code (str): The code to run in the terminal.
Returns:
str: The output of the code.
"""
out = subprocess.run(code, shell=True, capture_output=True, text=True).stdout
return str(out)
# Initialize the agent with a tool
agent = Agent(
agent_name="Terminal-Agent",
llm=OpenAIChat(api_key=os.getenv("OPENAI_API_KEY")),
tools=[terminal],
system_prompt="You are an agent that can execute terminal commands. Use the tools provided to assist the user.",
)
# Run the agent
response = agent.run("List the contents of the current directory")
print(response)
Long-term Memory Management¶
The Swarm Agent supports integration with vector databases for long-term memory management. Here's an example using ChromaDB:
from swarms import Agent
from swarm_models import Anthropic
from swarms_memory import ChromaDB
# Initialize ChromaDB
chromadb = ChromaDB(
metric="cosine",
output_dir="finance_agent_rag",
)
# Initialize the agent with long-term memory
agent = Agent(
agent_name="Financial-Analysis-Agent",
llm=Anthropic(anthropic_api_key=os.getenv("ANTHROPIC_API_KEY")),
long_term_memory=chromadb,
system_prompt="You are a financial analysis agent with access to long-term memory.",
)
# Run the agent
response = agent.run("What are the components of a startup's stock incentive equity plan?")
print(response)
Interactive Mode¶
To enable interactive mode, set the interactive
parameter to True
when initializing the Agent
:
agent = Agent(
agent_name="Interactive-Agent",
llm=OpenAIChat(api_key=os.getenv("OPENAI_API_KEY")),
interactive=True,
system_prompt="You are an interactive agent. Engage in a conversation with the user.",
)
# Run the agent in interactive mode
agent.run("Let's start a conversation")
Sentiment Analysis¶
To perform sentiment analysis on the agent's outputs, you can provide a sentiment analyzer function:
from textblob import TextBlob
def sentiment_analyzer(text):
analysis = TextBlob(text)
return analysis.sentiment.polarity
agent = Agent(
agent_name="Sentiment-Analysis-Agent",
llm=OpenAIChat(api_key=os.getenv("OPENAI_API_KEY")),
sentiment_analyzer=sentiment_analyzer,
sentiment_threshold=0.5,
system_prompt="You are an agent that generates responses with sentiment analysis.",
)
response = agent.run("Generate a positive statement about AI")
print(response)
Undo Functionality¶
# Feature 2: Undo functionality
response = agent.run("Another task")
print(f"Response: {response}")
previous_state, message = agent.undo_last()
print(message)
Response Filtering¶
# Feature 3: Response filtering
agent.add_response_filter("report")
response = agent.filtered_run("Generate a report on finance")
print(response)
Saving and Loading State¶
# Save the agent state
agent.save_state('saved_flow.json')
# Load the agent state
agent = Agent(llm=llm_instance, max_loops=5)
agent.load('saved_flow.json')
agent.run("Continue with the task")
Async and Concurrent Execution¶
# Run a task concurrently
response = await agent.run_concurrent("Concurrent task")
print(response)
# Run multiple tasks concurrently
tasks = [
{"task": "Task 1"},
{"task": "Task 2", "img": "path/to/image.jpg"},
{"task": "Task 3", "custom_param": 42}
]
responses = agent.bulk_run(tasks)
print(responses)
Various other settings¶
# # Convert the agent object to a dictionary
print(agent.to_dict())
print(agent.to_toml())
print(agent.model_dump_json())
print(agent.model_dump_yaml())
# Ingest documents into the agent's knowledge base
agent.ingest_docs("your_pdf_path.pdf")
# Receive a message from a user and process it
agent.receive_message(name="agent_name", message="message")
# Send a message from the agent to a user
agent.send_agent_message(agent_name="agent_name", message="message")
# Ingest multiple documents into the agent's knowledge base
agent.ingest_docs("your_pdf_path.pdf", "your_csv_path.csv")
# Run the agent with a filtered system prompt
agent.filtered_run(
"How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria?"
)
# Run the agent with multiple system prompts
agent.bulk_run(
[
"How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria?",
"Another system prompt",
]
)
# Add a memory to the agent
agent.add_memory("Add a memory to the agent")
# Check the number of available tokens for the agent
agent.check_available_tokens()
# Perform token checks for the agent
agent.tokens_checks()
# Print the dashboard of the agent
agent.print_dashboard()
# Fetch all the documents from the doc folders
agent.get_docs_from_doc_folders()
# Activate agent ops
agent.activate_agentops()
agent.check_end_session_agentops()
# Dump the model to a JSON file
agent.model_dump_json()
print(agent.to_toml())
Auto Generate Prompt + CPU Execution¶
import os
from swarms import Agent
from swarm_models import OpenAIChat
from dotenv import load_dotenv
# Load environment variables
load_dotenv()
# Retrieve the OpenAI API key from the environment variable
api_key = os.getenv("GROQ_API_KEY")
# Initialize the model for OpenAI Chat
model = OpenAIChat(
openai_api_base="https://api.groq.com/openai/v1",
openai_api_key=api_key,
model_name="llama-3.1-70b-versatile",
temperature=0.1,
)
# Initialize the agent with automated prompt engineering enabled
agent = Agent(
agent_name="Financial-Analysis-Agent",
system_prompt=None, # System prompt is dynamically generated
agent_description=None,
llm=model,
max_loops=1,
autosave=True,
dashboard=False,
verbose=False,
dynamic_temperature_enabled=True,
saved_state_path="finance_agent.json",
user_name="Human:",
return_step_meta=False,
output_type="string",
streaming_on=False,
auto_generate_prompt=True, # Enable automated prompt engineering
)
# Run the agent with a task description and specify the device
agent.run(
"How can I establish a ROTH IRA to buy stocks and get a tax break? What are the criteria",
## Will design a system prompt based on the task if description and system prompt are None
device="cpu",
)
# Print the dynamically generated system prompt
print(agent.system_prompt)
Best Practices¶
- Always provide a clear and concise
system_prompt
to guide the agent's behavior. - Use
tools
to extend the agent's capabilities for specific tasks. - Implement error handling and utilize the
retry_attempts
feature for robust execution. - Leverage
long_term_memory
for tasks that require persistent information. - Use
interactive
mode for real-time conversations anddashboard
for monitoring. - Implement
sentiment_analysis
for applications requiring tone management. - Utilize
autosave
andsave
/load
methods for continuity across sessions. - Optimize token usage with
dynamic_context_window
andtokens_checks
methods. - Use
concurrent
andasync
methods for performance-critical applications. - Regularly review and analyze feedback using the
analyze_feedback
method. - Use
artifacts_on
to save important outputs from agent execution - Configure
device
anddevice_id
appropriately for optimal performance - Enable
rag_every_loop
when continuous context from long-term memory is needed - Use
scheduled_run_date
for automated task scheduling
By following these guidelines and leveraging the Swarm Agent's extensive features, you can create powerful, flexible, and efficient autonomous agents for a wide range of applications.