Build highly capable Single and Multi-Agent Systems.
# BondAI Homepage Checkout the BondAI Homepage ([https://bondai.dev](https://bondai.dev)) for in depth documentation, examples and API specification. # Getting Started There are 3 ways to use BondAI: 1) 🛠️ **Command Line Interface (CLI)** - This is the easiest way to get up and running fast. Run BondAI on your command line with a pre-configured set of tools. 2) 🐋 **Docker** - Running BondAI in a Docker container is recommended if you plan on using tools that run code or directly access your shell. 3) 🏗️ **Start Coding with BondAI** - Integrate BondAI into your own codebase and start building your own agents. ## 🚀 Installation Installing BondAI is easy: ```bash pip install bondai ``` ## 🛠️ Command Line Interface (CLI) Once you've installed BondAI using `pip install bondai` the CLI will be available as an executable accessible simply by running `bondai` in your shell. [Learn more about all of the tools and options available through the CLI](https://bondai.dev/docs/cli). Before running `bondai` you will need to set the OPENAI_API_KEY environment variable. ```bash export OPENAI_API_KEY=sk-XXXXXXXXXX ``` Once the environment variable has been set you can run `bondai` to start the CLI. ```bash Loading BondAI... ******************ENTERING CHAT****************** You are entering a chat with BondAI... You can exit any time by typing 'exit'. Hello! I'm BondAI, your friendly and helpful assistant. I'm here to assist you with any tasks or questions you might have. How can I assist you today? I want you to write a story about unicorns and save it to a file named unicorns.md. Using tool file_write: Writing a story about unicorns and saving it to a file named unicorns.md Using tool final_answer... A story about unicorns has been successfully written and saved to a file named unicorns.md. The story is set in an enchanted forest and describes the magical and majestic nature of unicorns, their daily routines, and their harmonious relationship with other creatures in the forest. ``` ## 🐋 Docker BondAI Docker images are available on [DockerHub here](https://hub.docker.com/r/krohling/bondai). If you intend to use tools that run arbitrary code (*PythonREPLTool*) or access your shell (*ShellTool*) it is highly recommended that you run BondAI in a Docker container as these tools can damage your machine. Before running the BondAI Docker container it is recommended that you create a directory named 'agent-volume' and mount it as a volume on the container. This will be used as the Agent's working directory and allows you to easily share files with the Agent. ```bash mkdir agent-volume docker pull krohling/bondai:latest docker run -it --rm \ -v ./agent-volume:/agent-volume \ -w /agent-volume \ OPENAI_API_KEY=sk-XXXXXXXXXX \ bondai:latest bondai ``` ## 🔥 Start Coding with BondAI BondAI has a straightforward API for creating powerful AI Agents. Check out our [examples](https://bondai.dev/docs/category/examples) for ideas on how to get started. Remember to set your *OPENAI_API_KEY* environment variable before running your BondAI Agent. ```python from bondai.agents import Agent from bondai.tools.search import DuckDuckGoSearchTool from bondai.tools.website import WebsiteQueryTool from bondai.tools.file import FileWriteTool task = """I want you to research the usage of Metformin as a drug to treat aging and aging related illness. You should only use reputable information sources, ideally peer reviewed scientific studies. I want you to summarize your findings in a document named metformin.md and includes links to reference and resources you used to find the information. Additionally, the last section of your document you should provide a recommendation for a 43 year old male, in good health and who regularly exercises as to whether he would benefit from taking Metformin. You should explain your recommendation and justify it with sources. Finally, you should highlight potential risks and tradeoffs from taking the medication.""" Agent(tools=[ DuckDuckGoSearchTool(), WebsiteQueryTool(), FileWriteTool() ]).run(task) ``` ## BondAI Integrations BondAI comes out of the box with a powerful set of integrations. | | | | | -------- | ------- |------- | |
| **OpenAI** | BondAI supports any combination of OpenAI models and services including GPT-4, GPT-3.5, Dalle-E 3, and Embeddings. |
| 
| **Microsoft Azure** | BondAI fully supports connectivity to GPT-N, Dalle-E and Embedding APIs through [Microsoft's Azure OpenAI services](https://azure.microsoft.com/en-us/products/ai-services/openai-service). |
| 
| **Google Search** | Allows BondAI to search the internet. [Requires a Google Search API Key and CSE ID](https://developers.google.com/custom-search/v1/introduction) |
| 
| **DuckDuckGo** | Allows BondAI to search the internet. No API keys required. |
| 
| **Alpaca Markets** | Allows BondAI to buy and sell stocks and crypto. [Requires an Alpaca Markets account.](https://alpaca.markets/) |
| 
| **PostgreSQL** | BondAI can automatically extract the schema from a Postgres DB and process natural language queries. |
| 
| **Bland AI** | Allows BondAI to make phone calls and process/retrieve call transcripts. [Requires a Bland.ai account.](https://www.bland.ai/) |
| 
| **Gmail** | Allows BondAI to search and read emails. |
================================================
FILE: bondai/__init__.py
================================================
================================================
FILE: bondai/agents/__init__.py
================================================
from .conversational_agent import ConversationalAgent
from .agent import Agent, DEFAULT_MESSAGE_PROMPT_TEMPLATE
from .conversation_member import ConversationMember, ConversationMemberEventNames
from .messages import (
AgentMessage,
SystemMessage,
ConversationMessage,
ToolUsageMessage,
AgentMessageList,
message_to_dict,
USER_MEMBER_NAME,
)
from .util import (
AgentStatus,
AgentEventNames,
AgentException,
BudgetExceededException,
MaxStepsExceededException,
parse_response_content_message,
)
__all__ = [
"ConversationalAgent",
"Agent",
"parse_response_content_message",
"DEFAULT_MESSAGE_PROMPT_TEMPLATE",
"AgentStatus",
"AgentEventNames",
"AgentException",
"BudgetExceededException",
"MaxStepsExceededException",
"ConversationMember",
"ConversationMemberEventNames",
"AgentMessage",
"SystemMessage",
"ConversationMessage",
"ToolUsageMessage",
"AgentMessageList",
"message_to_dict",
"USER_MEMBER_NAME",
]
================================================
FILE: bondai/agents/agent.py
================================================
import os
import uuid
import traceback
from pydantic import BaseModel
from datetime import datetime
from typing import Dict, List, Tuple, Callable
from bondai.util import EventMixin, Runnable, load_local_resource
from bondai.tools import Tool, ResponseQueryTool
from bondai.models import LLM, EmbeddingModel
from bondai.memory import MemoryManager
from bondai.prompt import JinjaPromptBuilder
from bondai.models.openai import (
OpenAILLM,
OpenAIEmbeddingModel,
OpenAIModelNames,
get_total_cost,
)
from .conversation_member import ConversationMember
from .messages import AgentMessage, AgentMessageList, SystemMessage, ToolUsageMessage
from .compression import summarize_conversation, summarize_messages
from .util import (
AgentStatus,
AgentEventNames,
AgentException,
BudgetExceededException,
MaxStepsExceededException,
ContextLengthExceededException,
count_request_tokens,
format_llm_messages,
execute_tool,
)
DEFAULT_MAX_TOOL_RETRIES = 5
DEFAULT_MAX_TOOL_RESPONSE_TOKENS = 2000
DEFAULT_SYSTEM_PROMPT_TEMPLATE = load_local_resource(
__file__, os.path.join("prompts", "react_agent_system_prompt_template.md")
)
DEFAULT_MESSAGE_PROMPT_TEMPLATE = load_local_resource(
__file__, os.path.join("prompts", "agent_message_prompt_template.md")
)
class FinalAnswerParameters(BaseModel):
results: str
class FinalAnswerTool(Tool):
def __init__(self):
super().__init__(
"final_answer",
"Use the final_answer tool once you have completed your TASK. Provide a highly detailed description of the results of your task in the 'results' parameter.",
FinalAnswerParameters,
)
def run(self, results: str) -> Tuple[str, bool]:
return results, True
class Agent(EventMixin, Runnable):
def __init__(
self,
llm: LLM | None = None,
embedding_model: EmbeddingModel | None = None,
tools: List[Tool] | None = None,
quiet: bool = True,
allowed_events: List[str] | None = None,
messages: List[AgentMessage] | None = None,
system_prompt_sections: List[Callable[[], str]] | None = None,
system_prompt_builder: Callable[..., str] = None,
message_prompt_builder: Callable[..., str] = None,
memory_manager: MemoryManager | None = None,
max_context_length: int = None,
max_context_pressure_ratio: float = 0.8,
max_tool_retries: int = DEFAULT_MAX_TOOL_RETRIES,
max_tool_response_tokens=DEFAULT_MAX_TOOL_RESPONSE_TOKENS,
enable_context_compression: bool = False,
enable_final_answer_tool: bool = True,
):
Runnable.__init__(self)
if allowed_events is None:
allowed_events = [
AgentEventNames.TOOL_SELECTED,
AgentEventNames.TOOL_COMPLETED,
AgentEventNames.TOOL_ERROR,
AgentEventNames.STREAMING_CONTENT_UPDATED,
AgentEventNames.STREAMING_FUNCTION_UPDATED,
AgentEventNames.CONTEXT_COMPRESSION_REQUESTED,
]
EventMixin.__init__(self, allowed_events=allowed_events)
if llm is None:
llm = OpenAILLM(OpenAIModelNames.GPT4_0613)
if embedding_model is None:
embedding_model = OpenAIEmbeddingModel(
OpenAIModelNames.TEXT_EMBEDDING_ADA_002
)
if tools is None:
tools = []
if system_prompt_sections is None:
system_prompt_sections = []
if messages is None:
messages = []
self._id: str = str(uuid.uuid4())
self._status: AgentStatus = AgentStatus.IDLE
self._messages = AgentMessageList(messages=messages)
self._llm: LLM = llm
self._embedding_model: EmbeddingModel = embedding_model
self._tools: List[Tool] = tools
self._quiet: bool = quiet
self._system_prompt_sections: List[Callable[[], str]] = system_prompt_sections
self._system_prompt_builder: Callable[..., str] = system_prompt_builder
self._message_prompt_builder: Callable[..., str] = message_prompt_builder
self._memory_manager = memory_manager
self._max_context_length = (
max_context_length if max_context_length else (self._llm.max_tokens * 0.95)
)
self._max_context_pressure_ratio = max_context_pressure_ratio
self._max_tool_retries = max_tool_retries
self._max_tool_response_tokens = max_tool_response_tokens
self._enable_context_compression = enable_context_compression
if self._memory_manager:
self._tools.extend(self._memory_manager.tools)
self._system_prompt_sections.append(self._memory_manager)
if self._system_prompt_builder is None:
self._system_prompt_builder = JinjaPromptBuilder(
DEFAULT_SYSTEM_PROMPT_TEMPLATE
)
if self._message_prompt_builder is None:
self._message_prompt_builder = JinjaPromptBuilder(
DEFAULT_MESSAGE_PROMPT_TEMPLATE
)
if enable_final_answer_tool:
self._tools.append(FinalAnswerTool())
@property
def id(self) -> str:
return self._id
@property
def status(self) -> AgentStatus:
return self._status
@property
def tools(self) -> List[Tool]:
return self._tools
def clear_messages(self):
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot reset memory while agent is in a running state."
)
self._messages.clear()
def add_tool(self, tool: Tool):
if not any([t.name == tool.name for t in self._tools]):
self.tools.append(tool)
def remove_tool(self, tool_name: str):
self._tools = [t for t in self._tools if t.name != tool_name]
def to_dict(self) -> Dict:
return {"id": self.id, "tools": [t.name for t in self._tools]}
def save_state(self) -> Dict:
if self._status == AgentStatus.RUNNING:
raise AgentException("Cannot save agent state while it is running.")
state = {"tools": {}}
for tool in self._tools:
state["tools"][tool.name] = tool.save_state()
return state
def load_state(self, state: Dict):
if self._status == AgentStatus.RUNNING:
raise AgentException("Cannot load agent state while it is running.")
for tool in self._tools:
if tool.name in state["tools"]:
tool.load_state(state["tools"][tool.name])
def _is_context_pressure_too_high(
self,
llm_messages: List[Dict[str, str]],
tools: List[Tool] | None = None,
) -> float:
if tools is None:
tools = []
context_pressure_ratio = float(
count_request_tokens(self._llm, llm_messages, tools)
) / float(self._max_context_length)
return context_pressure_ratio > self._max_context_pressure_ratio
def _get_llm_response(
self,
messages: List[Dict] | None = None,
tools: List[Tool] | None = None,
content_stream_callback: Callable[[str], None] | None = None,
function_stream_callback: Callable[[str], None] | None = None,
) -> (str | None, Dict | None):
if messages is None:
messages = []
if tools is None:
tools = []
request_tokens = count_request_tokens(
llm=self._llm, messages=messages, tools=tools
)
if request_tokens > self._llm.max_tokens:
raise ContextLengthExceededException(
f"Context length ({request_tokens}) exceeds maximum tokens allowed by LLM: {self._llm.max_tokens}"
)
llm_functions = list(map(lambda t: t.get_tool_function(), tools))
if (
self._llm.supports_streaming
): # and (any([t.supports_streaming for t in tools]) or content_stream_callback):
def _function_stream_callback(function_name, arguments_buffer):
streaming_tools: [Tool] = [
t for t in tools if t.name == function_name and t.supports_streaming
]
if len(streaming_tools) > 0:
tool: Tool = streaming_tools[0]
tool.handle_stream_update(arguments_buffer)
if function_stream_callback:
function_stream_callback(function_name, arguments_buffer)
self._trigger_event(
AgentEventNames.STREAMING_FUNCTION_UPDATED,
self,
function_name,
arguments_buffer,
)
def _content_stream_callback(content_buffer):
if content_stream_callback:
content_stream_callback(content_buffer)
self._trigger_event(
AgentEventNames.STREAMING_CONTENT_UPDATED, self, content_buffer
)
llm_response, llm_response_function = self._llm.get_streaming_completion(
messages=messages,
functions=llm_functions,
function_stream_callback=_function_stream_callback,
content_stream_callback=_content_stream_callback,
)
else:
llm_response, llm_response_function = self._llm.get_completion(
messages=messages,
functions=llm_functions,
# function_stream_callback=function_stream_callback,
# content_stream_callback=content_stream_callback
)
return llm_response, llm_response_function
def run(
self,
task: str,
max_steps: int = None,
max_budget: float = None,
) -> ToolUsageMessage | str:
if self._status == AgentStatus.RUNNING:
raise AgentException("Cannot start agent while it is in a running state.")
self._status = AgentStatus.RUNNING
try:
return self._run_tool_loop(
tools=self._tools,
task=task,
starting_cost=get_total_cost(),
max_budget=max_budget,
max_steps=max_steps,
)
finally:
self._status = AgentStatus.IDLE
def run_async(
self,
task: str,
max_steps: int = None,
max_budget: float = None,
):
"""Runs the agent's task in a separate thread."""
if self._status == AgentStatus.RUNNING:
raise AgentException("Cannot start agent while it is in a running state.")
args = (task, max_steps, max_budget)
self._start_execution_thread(target=self.run, args=args)
def stop(self, timeout=10):
"""Gracefully stops the thread, with a timeout."""
self._force_stop = True
for tool in self._tools:
tool.stop()
super().stop(timeout=timeout)
def _run_tool_loop(
self,
tools: List[Tool],
starting_cost: float,
max_budget: float = None,
max_steps: int = None,
max_tool_retries: int = None,
task: str | None = None,
prompt_vars: Dict | None = None,
return_conversational_responses: bool = False,
retain_tool_messages_in_context: bool = True,
addition_context_messages: List[AgentMessage] | None = None,
conversation_members: List[ConversationMember] | None = None,
content_stream_callback: Callable[[str], None] | None = None,
function_stream_callback: Callable[[str], None] | None = None,
) -> ToolUsageMessage | str:
if addition_context_messages is None:
addition_context_messages = []
if conversation_members is None:
conversation_members = []
if max_tool_retries is None:
max_tool_retries = self._max_tool_retries
error_count = 0
step_count = 0
last_error_message = None
local_messages = []
self._force_stop = False
response_query_tool = ResponseQueryTool(
llm=self._llm, embedding_model=self._embedding_model
)
def append_message(message):
if isinstance(message, SystemMessage):
system_messages = [
m for m in local_messages if not isinstance(m, SystemMessage)
]
for m in system_messages:
local_messages.remove(m)
local_messages.append(message)
if retain_tool_messages_in_context:
self._messages.add(message)
if self._memory_manager and self._memory_manager.conversation_memory:
self._memory_manager.conversation_memory.add(message)
while not self._force_stop:
step_count += 1
if max_budget and get_total_cost() - starting_cost > max_budget:
raise BudgetExceededException()
if max_steps and step_count > max_steps:
raise MaxStepsExceededException()
if (
len(response_query_tool.responses) > 0
and response_query_tool not in tools
):
tools.append(response_query_tool)
if self._enable_context_compression:
self._compress_llm_context(
tools=tools,
last_error_message=last_error_message,
conversation_members=conversation_members,
additional_context_messages=addition_context_messages
+ local_messages,
prompt_vars=prompt_vars,
)
llm_context = self._build_llm_context(
messages=AgentMessageList(
self._messages + addition_context_messages + local_messages
),
tools=tools,
task=task,
last_error_message=last_error_message,
conversation_members=conversation_members,
prompt_vars=prompt_vars,
)
llm_response_content, llm_response_function = self._get_llm_response(
messages=llm_context,
tools=tools,
content_stream_callback=content_stream_callback,
function_stream_callback=function_stream_callback,
)
# print(llm_response_content)
last_error_message = None
if llm_response_function and any(
[
m.name == llm_response_function.get("tool_name")
for m in conversation_members
]
):
message = f"""MessageSendFailure: You attempted to send a message to {llm_response_function.get('tool_name')} but this message failed.
To send a message to {llm_response_function.get('tool_name')} you must use the 'send_message' tool or use this format in your response:
```
{llm_response_function.get('tool_name')}: Include your message here.)
```
"""
append_message(SystemMessage(message=message))
if llm_response_function:
tool_message = ToolUsageMessage(
tool_name=llm_response_function["name"],
tool_arguments=llm_response_function.get("arguments") or {},
)
self._trigger_event(AgentEventNames.TOOL_SELECTED, self, tool_message)
self._handle_llm_function(tool_message=tool_message, tools=tools)
if (
isinstance(tool_message.tool_output, str)
and self._llm.count_tokens(tool_message.tool_output)
> self._max_tool_response_tokens
):
response_id = response_query_tool.add_response(
tool_message.tool_output
)
tool_message.tool_output = f"The result from this tool was greater than {self._max_tool_response_tokens} tokens and could not be displayed. However, you can use the response_query tool to ask questions about the content of this response. Just use response_id = {response_id}."
append_message(tool_message)
if tool_message.success:
error_count = 0
self._trigger_event(
AgentEventNames.TOOL_COMPLETED, self, tool_message
)
if tool_message.agent_halted:
return tool_message
else:
error_count += 1
last_error_message = str(tool_message.error)
message = "ToolUsageError: Your last tool usage failed and MUST BE CORRECTED. If this error is not corrected you will not be able to proceed."
append_message(SystemMessage(message=message))
self._trigger_event(AgentEventNames.TOOL_ERROR, self, tool_message)
if error_count >= max_tool_retries:
return tool_message
elif llm_response_content and return_conversational_responses:
return llm_response_content
else:
error_count += 1
message = "InvalidResponseError: The response does not conform to the required format. A function selection was expected, but none was provided."
append_message(SystemMessage(message=message))
if error_count >= max_tool_retries:
raise AgentException(message)
if self._force_stop:
self._force_stop = False
raise AgentException("Agent was forcibly stopped.")
def _build_llm_context(
self,
messages: AgentMessageList,
tools: List[Tool] | None = None,
task: str | None = None,
last_error_message: str | None = None,
conversation_members: List[ConversationMember] | None = None,
truncate_context: bool = True,
prompt_vars: Dict | None = None,
) -> (str | None, Dict | None):
if tools is None:
tools = []
if conversation_members is None:
conversation_members = []
if prompt_vars is None:
prompt_vars = {}
prompt_sections = []
for s in self._system_prompt_sections:
if callable(s):
prompt_sections.append(s())
else:
prompt_sections.append(s)
system_prompt: str = self._system_prompt_builder(
conversation_members=conversation_members,
tools=tools,
task=task,
prompt_sections=prompt_sections,
error_message=last_error_message,
**prompt_vars,
)
# print(system_prompt)
llm_context = format_llm_messages(
system_prompt, messages, self._message_prompt_builder
)
if truncate_context:
reduced_messages = AgentMessageList(messages)
while (
self._is_context_pressure_too_high(llm_context, tools)
and len(reduced_messages) > 0
):
reduced_messages.remove(reduced_messages[0])
llm_context = format_llm_messages(
system_prompt, reduced_messages, self._message_prompt_builder
)
return llm_context
def _compress_llm_context(
self,
tools: List[Tool] | None = None,
last_error_message: str | None = None,
conversation_members: List[ConversationMember] | None = None,
additional_context_messages: List[AgentMessage] | None = None,
prompt_vars: Dict | None = None,
) -> List[AgentMessage]:
if tools is None:
tools = []
if conversation_members is None:
conversation_members = []
if additional_context_messages is None:
additional_context_messages = []
all_context_messages = AgentMessageList(
self._messages + additional_context_messages
)
llm_context = self._build_llm_context(
messages=all_context_messages,
tools=tools,
last_error_message=last_error_message,
conversation_members=conversation_members,
truncate_context=False,
prompt_vars=prompt_vars,
)
if self._is_context_pressure_too_high(llm_context, tools):
# Try summarizing individual messages
# TODO: Give the agent an opportunity to save information to Archival database
summarize_messages(
llm=self._llm,
messages=self._messages[:-1],
message_prompt_builder=self._message_prompt_builder,
)
llm_context = self._build_llm_context(
messages=all_context_messages,
tools=tools,
last_error_message=last_error_message,
conversation_members=conversation_members,
truncate_context=False,
prompt_vars=prompt_vars,
)
if self._is_context_pressure_too_high(llm_context, tools):
# Try summarizing the entire conversation
last_message = self._messages[-1]
summary_message = summarize_conversation(
llm=self._llm,
messages=self._messages[:-1],
message_prompt_builder=self._message_prompt_builder,
)
self._messages.clear()
self._messages.add(summary_message)
self._messages.add(last_message)
all_context_messages = AgentMessageList(
self._messages + additional_context_messages
)
llm_context = self._build_llm_context(
messages=all_context_messages,
tools=tools,
last_error_message=last_error_message,
conversation_members=conversation_members,
truncate_context=False,
prompt_vars=prompt_vars,
)
if self._is_context_pressure_too_high(llm_context, tools):
# Fire a message for group conversation compression
self._trigger_event(
AgentEventNames.CONTEXT_COMPRESSION_REQUESTED, self
)
llm_context = self._build_llm_context(
messages=all_context_messages,
tools=tools,
last_error_message=last_error_message,
conversation_members=conversation_members,
truncate_context=False,
prompt_vars=prompt_vars,
)
if self._is_context_pressure_too_high(llm_context, tools):
print(
"Warning: Context compression failed to relieve pressure."
)
def _handle_llm_function(self, tool_message: ToolUsageMessage, tools: List[Tool]):
tool_starting_cost = get_total_cost()
try:
tool_output = execute_tool(
tool_name=tool_message.tool_name,
tool_arguments=tool_message.tool_arguments,
tools=tools,
)
agent_halted = False
if isinstance(tool_output, tuple):
tool_output, agent_halted = tool_output
tool_message.agent_halted = agent_halted
tool_message.tool_output = tool_output
tool_message.success = True
except Exception as e:
# traceback.print_exc()
tool_message.error = e
tool_message.completed_at = datetime.now()
tool_message.cost = get_total_cost() - tool_starting_cost
================================================
FILE: bondai/agents/compression/__init__.py
================================================
from .conversation_summarizer import summarize_conversation
from .message_summarizer import summarize_messages
__all__ = ["summarize_conversation", "summarize_messages"]
================================================
FILE: bondai/agents/compression/conversation_summarizer.py
================================================
import os
from typing import List
from bondai.models import LLM
from bondai.prompt import PromptBuilder, JinjaPromptBuilder
from bondai.util import load_local_resource
from bondai.agents.messages import (
AgentMessage,
SummaryMessage,
)
DEFAULT_SUMMARY_PROMPT_TEMPLATE = load_local_resource(
__file__, os.path.join("prompts", "conversation_summarizer_prompt_template.md")
)
def summarize_conversation(
llm: LLM,
messages: List[AgentMessage],
message_prompt_builder: PromptBuilder,
summary_prompt_builder: PromptBuilder = JinjaPromptBuilder(
DEFAULT_SUMMARY_PROMPT_TEMPLATE
),
) -> AgentMessage:
if not messages:
return []
# Format the messages
message_prompts = [
message_prompt_builder.build_prompt(
message=msg,
)
for msg in messages
]
# Get the summary for the entire conversation
prompt = summary_prompt_builder.build_prompt(messages=message_prompts)
summary, _ = llm.get_completion(messages=[{"role": "system", "content": prompt}])
# Return the summary wrapped in an SummaryMessage
return SummaryMessage(
message=summary,
children=list(messages),
timestamp=messages[-1].timestamp,
)
================================================
FILE: bondai/agents/compression/message_summarizer.py
================================================
import os
from typing import List
from concurrent.futures import ThreadPoolExecutor, as_completed
from bondai.models import LLM
from bondai.prompt import PromptBuilder, JinjaPromptBuilder
from bondai.util import load_local_resource
from bondai.agents.messages import AgentMessage, ConversationMessage, ToolUsageMessage
MIN_SUMMARIZABLE_LENGTH = 250
DEFAULT_SUMMARY_PROMPT_TEMPLATE = load_local_resource(
__file__, os.path.join("prompts", "message_summarizer_prompt_template.md")
)
def summarize_messages(
llm: LLM,
messages: List[AgentMessage],
message_prompt_builder: PromptBuilder,
summary_prompt_builder: PromptBuilder = JinjaPromptBuilder(
DEFAULT_SUMMARY_PROMPT_TEMPLATE
),
max_summary_words: int = 100,
) -> List[AgentMessage]:
summarizable_messages = [
m
for m in messages
if (
isinstance(m, ConversationMessage)
and not m.message_summary
and len(m.message) > MIN_SUMMARIZABLE_LENGTH
)
or (
isinstance(m, ToolUsageMessage)
and not m.tool_output_summary
and len(m.tool_output) > MIN_SUMMARIZABLE_LENGTH
)
]
print(f"Summarizing {len(summarizable_messages)} messages...")
# Creating a thread pool executor to parallelize summary generation
with ThreadPoolExecutor() as executor:
futures = []
for m in summarizable_messages:
# Find all messages that occurred before the current message
previous_messages = [msg for msg in messages if msg.timestamp < m.timestamp]
# Submit the _summarize_message task to the executor
future = executor.submit(
_summarize_message,
m,
previous_messages[-5:],
llm,
summary_prompt_builder,
message_prompt_builder,
max_summary_words,
)
futures.append(future)
for future in as_completed(futures):
try:
future.result()
except Exception as exc:
print(f"Message summary generation generated an exception: {exc}")
return messages
def _summarize_message(
message: AgentMessage,
previous_messages: List[AgentMessage],
llm: LLM,
prompt_builder: PromptBuilder,
message_prompt_builder: PromptBuilder,
max_summary_words: int,
) -> str:
message_prompt = message_prompt_builder.build_prompt(message=message)
previous_message_prompts = [
message_prompt_builder.build_prompt(
message=msg,
)
for msg in previous_messages
]
prompt = prompt_builder.build_prompt(
message=message_prompt,
previous_messages=previous_message_prompts,
max_words=max_summary_words,
)
summary, _ = llm.get_completion(messages=[{"role": "system", "content": prompt}])
# print("************")
# print(f"Message: {message_prompt}")
# print(f"Summary: {summary}")
# print("************")
if isinstance(message, ConversationMessage):
print("Updating message summary...")
message.message_summary = summary
elif isinstance(message, ToolUsageMessage):
message.tool_output_summary = summary
# print(message)
================================================
FILE: bondai/agents/compression/prompts/conversation_summarizer_prompt_template.md
================================================
Read the entire conversation provided below and create a summary. Your task is to condense the key information and main points from the conversation into a concise summary. Focus on retaining critical details and insights from the dialogue.
# Conversation:
{% for msg in messages %}
- {{ msg }}
{% endfor %}
# Instructions:
- Aim to capture the essence and most significant aspects of the conversation in your summary.
- Ensure that all vital information, including key facts, decisions, and insights, are included in the summary.
- Produce a clear and coherent summary that reflects the main points of the conversation.
- Exclude any redundant or non-essential information from the summary.
- Present the summary in a concise and organized manner.
# Conversation Summary:
================================================
FILE: bondai/agents/compression/prompts/message_summarizer_prompt_template.md
================================================
Read the following conversation and summarize the final message:
# Conversation
{% for msg in previous_messages %}
- {{ msg }}
{% endfor %}
- {{ message }}
# Important Rules
- Use the preceding conversation as context but summarize ONLY the following message.
- Your summary must be no longer than {max_words} words.
- Output only the summary. Do NOT include anything else in your output.
Message To Summarize:
{{ message }}
Summary:
================================================
FILE: bondai/agents/conversation_member.py
================================================
import uuid
from abc import ABC, abstractmethod
from enum import Enum
from typing import List, Callable
from .messages import (
AgentMessage,
ConversationMessage,
AgentMessageList,
USER_MEMBER_NAME,
)
DEFAULT_MAX_SEND_ATTEMPTS = 3
class ConversationMemberEventNames(Enum):
MESSAGE_RECEIVED: str = "message_received"
MESSAGE_COMPLETED: str = "message_completed"
MESSAGE_ERROR: str = "message_error"
CONVERSATION_EXITED: str = "agent_exited"
class ConversationMember(ABC):
def __init__(
self,
name: str,
persona: str | None = None,
persona_summary: str | None = None,
):
self._id: str = str(uuid.uuid4())
self._name: str = name
self._persona: str = persona
self._persona_summary: str = persona_summary
self._messages: AgentMessageList = AgentMessageList()
@property
def id(self) -> str:
return self._id
@property
def name(self) -> str:
return self._name
@property
def persona(self) -> str:
return self._persona
@property
def persona_summary(self) -> str:
return self._persona_summary
@property
def messages(self) -> AgentMessageList:
return self._messages
@abstractmethod
def send_message(
self,
message: str | ConversationMessage,
sender_name: str = USER_MEMBER_NAME,
group_members: List | None = None,
group_messages: List[AgentMessage] | None = None,
max_attempts: int = DEFAULT_MAX_SEND_ATTEMPTS,
require_response: bool = True,
) -> (str, str, bool):
pass
def send_message_async(
self,
message: str | ConversationMessage,
sender_name: str = USER_MEMBER_NAME,
group_members: List | None = None,
group_messages: List[AgentMessage] | None = None,
max_attempts: int = DEFAULT_MAX_SEND_ATTEMPTS,
require_response: bool = True,
):
pass
def clear_messages(self):
pass
================================================
FILE: bondai/agents/conversational_agent.py
================================================
import os
import traceback
import json
from datetime import datetime
from typing import Dict, List, Callable
from bondai.util import load_local_resource
from bondai.tools import Tool
from bondai.memory import MemoryManager
from bondai.tools.conversational import (
SEND_MESSAGE_TOOL_NAME,
EXIT_CONVERSATION_TOOL_NAME,
SendMessageTool,
ExitConversationTool,
)
from bondai.prompt import JinjaPromptBuilder
from bondai.models import LLM, EmbeddingModel
from bondai.models.openai import OpenAILLM, OpenAIModelNames, get_total_cost
from .agent import (
Agent,
DEFAULT_MAX_TOOL_RETRIES,
AgentStatus,
AgentException,
)
from .util import (
AgentException,
AgentEventNames,
parse_response_content_message,
)
from .prompts import DEFAULT_AGENT_NAME, DEFAULT_CONVERSATIONAL_INSTRUCTIONS
from .conversation_member import ConversationMember, ConversationMemberEventNames
from .messages import (
AgentMessage,
ConversationMessage,
ToolUsageMessage,
SystemMessage,
AgentMessageList,
USER_MEMBER_NAME,
)
DEFAULT_MAX_SEND_ATTEMPTS = 3
DEFAULT_SYSTEM_PROMPT_TEMPLATE = load_local_resource(
__file__, os.path.join("prompts", "conversational_agent_system_prompt_template.md")
)
class ConversationalAgent(Agent, ConversationMember):
def __init__(
self,
llm: LLM | None = None,
embedding_model: EmbeddingModel | None = None,
tools: List[Tool] | None = None,
messages: List[AgentMessage] | None = None,
name: str = DEFAULT_AGENT_NAME,
persona: str | None = None,
persona_summary: str | None = None,
instructions: str | None = DEFAULT_CONVERSATIONAL_INSTRUCTIONS,
system_prompt_sections: List[Callable[[], str]] | None = None,
system_prompt_builder: Callable[..., str] = None,
message_prompt_builder: Callable[..., str] = None,
memory_manager: MemoryManager | None = None,
max_tool_retries: int = DEFAULT_MAX_TOOL_RETRIES,
max_context_length: int = None,
max_context_pressure_ratio: float = 0.8,
enable_context_compression: bool = False,
enable_conversation_tools: bool = True,
enable_conversational_content_responses: bool = True,
enable_exit_conversation: bool = True,
quiet: bool = True,
):
if llm is None:
llm = OpenAILLM(OpenAIModelNames.GPT4_0613)
if tools is None:
tools = []
if system_prompt_sections is None:
system_prompt_sections = []
ConversationMember.__init__(
self,
name=name,
persona=persona,
persona_summary=persona_summary,
)
Agent.__init__(
self,
llm=llm,
embedding_model=embedding_model,
quiet=quiet,
tools=tools,
messages=messages,
system_prompt_sections=system_prompt_sections,
system_prompt_builder=system_prompt_builder
or JinjaPromptBuilder(DEFAULT_SYSTEM_PROMPT_TEMPLATE),
message_prompt_builder=message_prompt_builder,
memory_manager=memory_manager,
max_context_length=max_context_length,
max_context_pressure_ratio=max_context_pressure_ratio,
max_tool_retries=max_tool_retries,
enable_context_compression=enable_context_compression,
enable_final_answer_tool=False,
allowed_events=[
AgentEventNames.CONTEXT_COMPRESSION_REQUESTED,
AgentEventNames.TOOL_SELECTED,
AgentEventNames.TOOL_ERROR,
AgentEventNames.TOOL_COMPLETED,
AgentEventNames.STREAMING_CONTENT_UPDATED,
AgentEventNames.STREAMING_FUNCTION_UPDATED,
ConversationMemberEventNames.MESSAGE_RECEIVED,
ConversationMemberEventNames.MESSAGE_ERROR,
ConversationMemberEventNames.MESSAGE_COMPLETED,
ConversationMemberEventNames.CONVERSATION_EXITED,
],
)
self._instructions: str = instructions
self._enable_exit_conversation: bool = enable_exit_conversation
self._enable_conversational_content_responses = (
enable_conversational_content_responses
)
self._enable_conversation_tools = enable_conversation_tools
if self._enable_conversation_tools:
self.add_tool(SendMessageTool())
if self._enable_exit_conversation:
self.add_tool(ExitConversationTool())
@property
def instructions(self) -> str:
return self._instructions
def send_message_async(
self,
message: str | ConversationMessage,
sender_name: str = USER_MEMBER_NAME,
group_members: List[ConversationMember] | None = None,
group_messages: List[AgentMessage] | None = None,
max_attempts: int = DEFAULT_MAX_SEND_ATTEMPTS,
require_response: bool = True,
):
"""Runs the agent's task in a separate thread."""
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot send message while agent is in a running state."
)
if not message:
raise AgentException("'message' cannot be empty.")
args = (
message,
sender_name,
group_members,
group_messages,
max_attempts,
require_response,
)
self._start_execution_thread(self.send_message, args=args)
def send_message(
self,
message: str | ConversationMessage,
sender_name: str = USER_MEMBER_NAME,
group_members: List[ConversationMember] | None = None,
group_messages: List[AgentMessage] | None = None,
max_attempts: int = DEFAULT_MAX_SEND_ATTEMPTS,
require_response: bool = True,
) -> ConversationMessage | None:
if group_members is None:
group_members = []
if group_messages is None:
group_messages = []
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot send message while agent is in a running state."
)
if not message:
raise AgentException("'message' cannot be empty.")
if isinstance(message, ConversationMessage):
agent_message = message
elif isinstance(message, str):
if not sender_name:
raise AgentException("sender_name cannot be empty.")
agent_message = ConversationMessage(
sender_name=sender_name,
recipient_name=self.name,
message=message,
require_response=require_response,
)
else:
raise AgentException(
"'message' must be an instance of ConversationMessage or a string."
)
attempts = 0
starting_cost = get_total_cost()
self._status = AgentStatus.RUNNING
self._messages.add(agent_message)
if self._memory_manager and self._memory_manager.conversation_memory:
self._memory_manager.conversation_memory.add(agent_message)
self._trigger_event(
ConversationMemberEventNames.MESSAGE_RECEIVED, self, agent_message
)
def complete_agent_message(
success=False, conversation_exited=False, error=None
):
agent_message.success = success
agent_message.conversation_exited = conversation_exited
agent_message.error = error
agent_message.cost = get_total_cost() - starting_cost
agent_message.completed_at = datetime.now()
if success:
self._trigger_event(
ConversationMemberEventNames.MESSAGE_COMPLETED, self, agent_message
)
if conversation_exited:
self._trigger_event(
ConversationMemberEventNames.CONVERSATION_EXITED,
self,
agent_message,
)
else:
self._trigger_event(
ConversationMemberEventNames.MESSAGE_ERROR, self, agent_message
)
def validate_recipient(recipient_name: str):
if not recipient_name:
return "recipient_name cannot be empty."
if len(group_members) > 0 and not any(
[
member.name.lower() == recipient_name.lower()
for member in group_members
]
):
return f"InvalidResponseError: The response does not conform to the required format. You do not have the ability to send messages to '{recipient_name}'. Try sending a message to someone else."
if not agent_message.require_response:
complete_agent_message(success=True)
return
while not self._force_stop:
try:
attempts += 1
if attempts > max_attempts:
raise AgentException(
"The maximum number of attempts has been exceeded."
)
prompt_vars = {
"name": self.name,
"persona": self.persona,
"instructions": self.instructions,
"conversation_enabled": self._enable_conversation_tools
or self._enable_conversational_content_responses,
"enable_exit_conversation": self._enable_exit_conversation,
}
tool_result = self._run_tool_loop(
addition_context_messages=group_messages,
tools=self._tools,
conversation_members=group_members,
starting_cost=starting_cost,
return_conversational_responses=True,
prompt_vars=prompt_vars,
)
response_message: ConversationMessage | None = None
if isinstance(tool_result, ToolUsageMessage):
if not tool_result.success:
complete_agent_message(success=False, error=tool_result.error)
raise tool_result.error
elif tool_result.tool_name == EXIT_CONVERSATION_TOOL_NAME:
complete_agent_message(success=True, conversation_exited=True)
return tool_result.tool_output
elif tool_result.tool_name == SEND_MESSAGE_TOOL_NAME:
response_message = tool_result.tool_output
if (
isinstance(tool_result, str)
and self._enable_conversational_content_responses
):
recipient_name, message = parse_response_content_message(
tool_result
)
if not recipient_name or not message:
recipient_name = agent_message.sender_name
message = tool_result
response_message = ConversationMessage(
role="assistant", recipient_name=recipient_name, message=message
)
if response_message:
response_message.sender_name = self.name
error = validate_recipient(response_message.recipient_name)
if not error:
complete_agent_message(success=True)
self._messages.add(response_message)
if (
self._memory_manager
and self._memory_manager.conversation_memory
):
self._memory_manager.conversation_memory.add(
response_message
)
return response_message
else:
self._messages.add(SystemMessage(message=error))
else:
self._messages.add(
SystemMessage(
message="InvalidResponseError: The response does not conform to the required format. A function selection was expected, but none was provided.\nYour must correct this error."
)
)
finally:
self._status = AgentStatus.IDLE
def to_dict(self) -> Dict:
data = super().to_dict()
data["name"] = self._name
data["persona"] = self._persona
data["persona_summary"] = self._persona_summary
data["instructions"] = self.instructions
data["quiet"] = self._quiet
data["enable_conversation_tools"] = self._enable_conversation_tools
data["enable_exit_conversation"] = self._enable_exit_conversation
data[
"enable_conversational_content_responses"
] = self._enable_conversational_content_responses
data["max_context_length"] = self._max_context_length
data["max_context_pressure_ratio"] = self._max_context_pressure_ratio
data["messages"] = self.messages.to_dict()
return data
def save_state(self, file_path: str = None) -> Dict:
state = super().save_state()
state.update(self.to_dict())
if file_path:
os.makedirs(os.path.dirname(file_path), exist_ok=True)
with open(file_path, "w") as file:
json.dump(state, file, indent=4)
return state
@classmethod
def from_dict(
cls, data: List[Dict], file_path: str = None
) -> "ConversationalAgent":
if not data and file_path:
with open(file_path, "r") as file:
data = json.load(file)
agent = cls(
name=data["name"],
persona=data["persona"],
persona_summary=data["persona_summary"],
instructions=data["instructions"],
enable_exit_conversation=data["enable_exit_conversation"],
quiet=data["quiet"],
enable_conversation_tools=data["enable_conversation_tools"],
enable_conversational_content_responses=data[
"enable_conversational_content_responses"
],
max_context_length=data["max_context_length"],
max_context_pressure_ratio=data["max_context_pressure_ratio"],
)
agent._messages = AgentMessageList.from_dict(data["messages"])
agent.load_state(data)
return agent
================================================
FILE: bondai/agents/group_chat/__init__.py
================================================
from .group_conversation import GroupConversation
from .user_proxy import UserProxy
from .group_conversation_config import (
BaseGroupConversationConfig,
GroupConversationConfig,
TeamConversationConfig,
TableConversationConfig,
CompositeConversationConfig,
)
__all__ = [
"UserProxy",
"GroupConversation",
"BaseGroupConversationConfig",
"GroupConversationConfig",
"TeamConversationConfig",
"TableConversationConfig",
"CompositeConversationConfig",
]
================================================
FILE: bondai/agents/group_chat/group_conversation.py
================================================
import uuid
import asyncio
import traceback
from datetime import datetime
from typing import Dict, List, Callable
from bondai.util import EventMixin, Runnable
from bondai.agents import (
AgentException,
AgentStatus,
ConversationMember,
ConversationMemberEventNames,
AgentMessageList,
ConversationMessage,
USER_MEMBER_NAME,
)
from .group_conversation_config import (
BaseGroupConversationConfig,
TeamConversationConfig,
)
class GroupConversation(EventMixin, Runnable):
def __init__(
self,
conversation_members: List[ConversationMember] | None = None,
conversation_config: BaseGroupConversationConfig | None = None,
filter_recipient_messages: bool = False,
):
super().__init__(
allowed_events=[
ConversationMemberEventNames.MESSAGE_RECEIVED,
ConversationMemberEventNames.MESSAGE_COMPLETED,
ConversationMemberEventNames.MESSAGE_ERROR,
ConversationMemberEventNames.CONVERSATION_EXITED,
]
)
if conversation_members and conversation_config:
raise AgentException(
"Only one of 'conversation_members' or 'conversation_configs' must be provided"
)
if conversation_config:
self._conversation_config = conversation_config
elif conversation_members:
self._conversation_config = TeamConversationConfig(conversation_members)
else:
raise AgentException(
"Either 'conversation_members' or 'conversation_config' must be provided"
)
self._id: str = str(uuid.uuid4())
self._status: AgentStatus = AgentStatus.IDLE
self._filter_recipient_messages: bool = filter_recipient_messages
self._messages: AgentMessageList = AgentMessageList()
self._init_member_events()
@property
def id(self) -> str:
return self._id
@property
def status(self) -> AgentStatus:
return self._status
@property
def members(self) -> List[ConversationMember]:
return self._conversation_config.members
def remove_messages_after(self, timestamp: datetime, inclusive: bool = True):
self._messages.remove_after(timestamp)
for a in self.members:
a.messages.remove_after(timestamp, inclusive=inclusive)
def _get_member(self, member_name: str) -> ConversationMember:
return next(
(m for m in self.members if m.name.lower() == member_name.lower()), None
)
def _init_member_events(self):
for member in self.members:
member.on(ConversationMemberEventNames.MESSAGE_RECEIVED)(
self._on_member_message_received
)
member.on(ConversationMemberEventNames.MESSAGE_ERROR)(
self._on_member_message_error
)
member.on(ConversationMemberEventNames.MESSAGE_COMPLETED)(
self._on_member_message_completed
)
member.on(ConversationMemberEventNames.CONVERSATION_EXITED)(
self._on_member_exited
)
def _on_member_message_received(
self, member: ConversationMember, message: ConversationMessage
):
# print(f"{message.sender_name} to {message.recipient_name}: {message.message}")
self._trigger_event(
ConversationMemberEventNames.MESSAGE_RECEIVED, member, message
)
def _on_member_message_error(
self, member: ConversationMember, message: ConversationMessage
):
exc = message.error
traceback.print_exception(type(exc), exc, exc.__traceback__)
self._trigger_event(ConversationMemberEventNames.MESSAGE_ERROR, member, message)
def _on_member_message_completed(
self, member: ConversationMember, message: ConversationMessage
):
self._messages.add(message)
self._trigger_event(
ConversationMemberEventNames.MESSAGE_COMPLETED, member, message
)
def _on_member_exited(
self, member: ConversationMember, message: ConversationMessage
):
self._trigger_event(
ConversationMemberEventNames.CONVERSATION_EXITED, member, message
)
def save_state(self) -> Dict:
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot save group conversation state while it is running."
)
state = {}
for member in self.members:
state[member.id] = member.save_state()
return state
def load_state(self, state: Dict):
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot load group conversation state while it is running."
)
for member in self.members:
member.load_state(state[member.id])
def send_message_async(
self,
recipient_name: str,
message: str,
sender_name: str = USER_MEMBER_NAME,
require_response: bool = True,
):
"""Runs the agent's task in a separate thread."""
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot send message while agent is in a running state."
)
if not message:
raise AgentException("'message' cannot be empty.")
args = (recipient_name, message, sender_name, require_response)
self._start_execution_thread(self.send_message, args=args)
def send_message(
self,
recipient_name: str,
message: str,
sender_name: str = USER_MEMBER_NAME,
require_response: bool = True,
) -> str:
if self._status == AgentStatus.RUNNING:
raise AgentException(
"Cannot send message while agent is in a running state."
)
if not message:
raise AgentException("'message' cannot be empty.")
previous_message = None
if isinstance(message, ConversationMessage):
next_message = message
elif isinstance(message, str):
if not sender_name:
raise AgentException("sender_name cannot be empty.")
if not recipient_name:
raise AgentException("recipient_name cannot be empty.")
next_message = ConversationMessage(
sender_name=sender_name,
recipient_name=recipient_name,
message=message,
require_response=require_response,
)
else:
raise AgentException(
"'message' must be an instance of ConversationMessage or a string."
)
try:
self._status = AgentStatus.RUNNING
while next_message:
if next_message.sender_name.lower() == USER_MEMBER_NAME.lower():
sender_reachable_members = self.members
else:
sender_reachable_members = (
self._conversation_config.get_reachable_members(
member_name=next_message.sender_name
)
)
recipient = next(
(
m
for m in sender_reachable_members
if m.name.lower() == next_message.recipient_name.lower()
),
None,
)
if not recipient:
raise AgentException(
f"Recipient {next_message.recipient_name} not found"
)
recipient_reachable_members = (
self._conversation_config.get_reachable_members(member=recipient)
)
if self._filter_recipient_messages:
recipient_messages = AgentMessageList(
[
m
for m in self._messages
if m.recipient_name.lower() == recipient.name.lower()
or m.sender_name.lower() == recipient.name.lower()
]
)
else:
recipient_messages = self._messages
try:
if next_message.require_response:
previous_message = next_message
next_message = recipient.send_message(
message=next_message,
group_members=recipient_reachable_members,
group_messages=recipient_messages,
)
else:
recipient.send_message(message=next_message)
next_message = previous_message
except AgentException as e:
print("Error occurred, rewinding conversation...")
# print(e)
# The recipient agent has errored out. We will rewind the conversation and try again.
previous_message = (
self._messages[-2]
if len(self._messages) > 1
else self._messages[-1]
)
self.remove_messages_after(previous_message.timestamp)
next_message = ConversationMessage(
message=previous_message.message,
sender_name=previous_message.sender_name,
recipient_name=previous_message.recipient_name,
)
self._trigger_event(
ConversationMemberEventNames.CONVERSATION_EXITED, next_message
)
finally:
self._status = AgentStatus.IDLE
def reset_memory(self):
self._messages.clear()
for member in self.members:
member.clear_messages()
================================================
FILE: bondai/agents/group_chat/group_conversation_config.py
================================================
from typing import Dict, List, Set
from abc import ABC, abstractmethod
from bondai.agents import ConversationMember
class BaseGroupConversationConfig(ABC):
@property
@abstractmethod
def members(self) -> List[ConversationMember]:
pass
@abstractmethod
def get_reachable_members(
self, member: ConversationMember | None = None, member_name: str = None
) -> List[ConversationMember]:
pass
class GroupConversationConfig(ABC):
def __init__(self, members: List[ConversationMember]):
self._members: Set[ConversationMember] = list(set(members))
@property
def _members(self) -> List[ConversationMember]:
return list(self._members)
def get_reachable_members(
self, member: ConversationMember | None = None, member_name: str = None
) -> List[ConversationMember]:
if not member and not member_name:
return []
member_name = "" if not member_name else member_name
reachable_members = list(
set(
[
m
for m in self._members
if m != member and m.name.lower() != member_name.lower()
]
)
)
return reachable_members
class TeamConversationConfig(BaseGroupConversationConfig):
def __init__(self, *args: List[ConversationMember]):
self._members: Set[ConversationMember] = set()
for team in args:
self._members.update(team)
self._teams: List[List[ConversationMember]] = list(args)
@property
def members(self) -> List[ConversationMember]:
return list(self._members)
def get_reachable_members(
self, member: ConversationMember | None = None, member_name: str = None
) -> List[ConversationMember]:
if not member and not member_name:
return []
member_name = "" if not member_name else member_name
member_teams = [
t
for t in self._teams
for m in t
if m == member or m.name.lower() == member_name.lower()
]
reachable_members = list(
set(
[
m
for t in member_teams
for m in t
if m != member and m.name.lower() != member_name.lower()
]
)
)
return reachable_members
class TableConversationConfig(BaseGroupConversationConfig):
def __init__(self, member_table: Dict):
self._member_table = member_table
@property
def members(self) -> List[ConversationMember]:
return list(self._member_table.keys())
def get_reachable_members(
self, member: ConversationMember | None = None, member_name: str = None
) -> List[ConversationMember]:
if not member and not member_name:
return []
if member_name:
member = next((m for m in self.members if m.name == member_name), None)
if member and member.name in self._member_table:
return self._member_table[member.name]
else:
return []
class CompositeConversationConfig(BaseGroupConversationConfig):
def __init__(self, *conversation_configs: List[BaseGroupConversationConfig]):
self._conversation_configs: List[BaseGroupConversationConfig] = list(
conversation_configs
)
@property
def members(self) -> List[ConversationMember]:
return list(set([m for c in self._conversation_configs for m in c.members]))
def get_reachable_members(
self, member: ConversationMember | None = None, member_name: str = None
) -> List[ConversationMember]:
return list(
set(
[
m
for c in self._conversation_configs
for m in c.get_reachable_members(member, member_name)
]
)
)
================================================
FILE: bondai/agents/group_chat/user_proxy.py
================================================
from termcolor import cprint
from datetime import datetime
from typing import List
from bondai.util import EventMixin
from bondai.agents import (
AgentStatus,
AgentException,
AgentMessage,
ConversationMessage,
ConversationMember,
ConversationMemberEventNames,
parse_response_content_message,
USER_MEMBER_NAME,
)
class UserProxy(EventMixin, ConversationMember):
def __init__(
self,
persona: str | None = None,
parse_recipients: bool = True,
auto_exit: bool = False,
):
EventMixin.__init__(
self,
allowed_events=[
ConversationMemberEventNames.MESSAGE_RECEIVED,
ConversationMemberEventNames.MESSAGE_ERROR,
ConversationMemberEventNames.MESSAGE_COMPLETED,
ConversationMemberEventNames.CONVERSATION_EXITED,
],
)
ConversationMember.__init__(
self,
name=USER_MEMBER_NAME,
persona=persona,
)
self._status = AgentStatus.IDLE
self._parse_recipients = parse_recipients
self._auto_exit = auto_exit
def send_message(
self,
message: str | ConversationMessage,
sender_name: str = USER_MEMBER_NAME,
group_members: List | None = None,
group_messages: List[AgentMessage] | None = None,
max_attempts: int = None,
require_response: bool = True,
):
if not message:
raise AgentException("'message' cannot be empty.")
if group_members is None:
group_members = []
if isinstance(message, ConversationMessage):
agent_message = message
else:
if not sender_name:
raise AgentException("sender_name cannot be empty.")
agent_message = ConversationMessage(
sender_name=sender_name,
recipient_name=self.name,
message=message,
require_response=require_response,
)
self._messages.add(agent_message)
self._trigger_event(
ConversationMemberEventNames.MESSAGE_RECEIVED, self, agent_message
)
cprint("\n" + agent_message.message + "\n", "white")
if not agent_message.require_response or self._auto_exit:
agent_message.success = True
agent_message.cost = 0.0
agent_message.completed_at = datetime.now()
self._trigger_event(
ConversationMemberEventNames.MESSAGE_COMPLETED, self, agent_message
)
return
while True:
try:
user_response = input()
user_exited = user_response.strip().lower() == "exit"
if not user_exited:
if self._parse_recipients:
(
next_recipient_name,
next_message,
) = parse_response_content_message(user_response)
else:
next_recipient_name = agent_message.sender_name
next_message = user_response
next_recipient_name = (
next_recipient_name
if next_recipient_name
else agent_message.sender_name
)
next_message = next_message if next_message else user_response
if len(group_members) > 0 and not any(
[
member.name.lower() == next_recipient_name.lower()
for member in group_members
]
):
raise AgentException(
f"InvalidResponseError: The response does not conform to the required format. You do not have the ability to send messages to '{next_recipient_name}'. Try sending a message to someone else."
)
agent_message.success = True
agent_message.conversation_exited = user_exited
agent_message.cost = 0.0
agent_message.completed_at = datetime.now()
self._trigger_event(
ConversationMemberEventNames.MESSAGE_COMPLETED,
self,
agent_message,
)
response_message = ConversationMessage(
sender_name=self.name,
recipient_name=next_recipient_name,
message=next_message,
)
self._messages.add(response_message)
self._status = AgentStatus.IDLE
return response_message
else:
agent_message.success = True
agent_message.conversation_exited = True
agent_message.cost = 0.0
agent_message.completed_at = datetime.now()
self._trigger_event(
ConversationMemberEventNames.MESSAGE_COMPLETED,
self,
agent_message,
)
self._trigger_event(
ConversationMemberEventNames.CONVERSATION_EXITED,
self,
agent_message,
)
self._status = AgentStatus.IDLE
return None
except Exception as e:
print("The following error occurred while parsing your response:")
print(str(e))
================================================
FILE: bondai/agents/messages.py
================================================
import uuid
from abc import ABC
from typing import List, Dict, Set
from datetime import datetime
from dataclasses import dataclass, field, is_dataclass
USER_MEMBER_NAME = "user"
DEFAULT_MEMORY_WARNING_MESSAGE = (
"Warning: the conversation history will soon reach its maximum length and be trimmed. "
"Make sure to save any important information from the conversation to your memory before it is removed."
)
@dataclass
class AgentMessage(ABC):
id: str = field(default_factory=lambda: str(uuid.uuid4()))
role: str | None = field(default=None)
timestamp: datetime = field(default_factory=lambda: datetime.now())
@dataclass
class SystemMessage(AgentMessage):
role: str = field(default="system")
message: str | None = field(default=None)
@dataclass
class SummaryMessage(AgentMessage):
role: str = field(default="user")
message: str | None = field(default=None)
children: List[AgentMessage] = field(default=None)
@dataclass
class ConversationMessage(AgentMessage):
role: str = field(default="user")
sender_name: str | None = field(default=None)
recipient_name: str | None = field(default=None)
message: str | None = field(default=None)
message_summary: str | None = field(default=None)
require_response: bool = field(default=True)
success: bool = field(default=False)
error: Exception | None = field(default=None)
conversation_exited: bool = field(default=False)
cost: float | None = field(default=None)
completed_at: datetime | None = field(default=None)
@dataclass
class ToolUsageMessage(AgentMessage):
role: str = field(default="function")
tool_name: str | None = field(default=None)
tool_arguments: Dict | None = field(default=None)
tool_output: str | None = field(default=None)
tool_output_summary: str | None = field(default=None)
success: bool = field(default=False)
error: Exception | None = field(default=None)
agent_halted: bool = field(default=False)
cost: float | None = field(default=None)
completed_at: datetime | None = field(default=None)
def custom_serialization(value):
"""
Serialize special types like datetime, Exception, and nested AgentMessage objects.
"""
if isinstance(value, datetime):
return value.isoformat()
elif isinstance(value, Exception):
return str(value)
elif is_dataclass(value) and not isinstance(value, type):
return message_to_dict(value)
return value
def message_to_dict(message: AgentMessage) -> Dict:
"""
Convert an AgentMessage object to a dictionary with custom serialization.
"""
message_dict = {
k: custom_serialization(v)
for k, v in message.__dict__.items()
if k != "children"
}
message_dict["type"] = type(message).__name__ # Add the type for deserialization
if "children" in message.__dict__:
message_dict["children"] = [
message_to_dict(child) for child in message.children
]
return message_dict
class AgentMessageList:
def __init__(self, messages: List[AgentMessage] | None = None):
self._items: List[AgentMessage] = []
self._ids: Set[str] = set()
if messages:
for message in messages:
self.add(message)
def add(self, item: AgentMessage):
if item.id not in self._ids:
self._ids.add(item.id)
self._items.append(item)
self._items = list(sorted(self._items, key=lambda x: x.timestamp))
def remove(self, item: AgentMessage):
if item.id in self._ids:
self._ids.remove(item.id)
self._items.remove(item)
def remove_after(self, timestamp: datetime, inclusive: bool = True):
if inclusive:
self._items = [item for item in self._items if item.timestamp <= timestamp]
else:
self._items = [item for item in self._items if item.timestamp < timestamp]
self._ids = set([item.id for item in self._items])
def clear(self):
self._items = []
self._ids = set()
def __getitem__(self, index: int):
return self._items[index]
def __add__(self, other: List[AgentMessage] | "AgentMessageList"):
if isinstance(other, AgentMessageList):
# If the other object is also an AgentMessageList, extend with its items
return self._items + other._items
elif isinstance(other, list):
# If the other object is a list, just concatenate the lists
return self._items + other
else:
# If the other object is neither, raise an exception
raise TypeError(
f"Unsupported operand type(s) for +: 'AgentMessageList' and '{type(other).__name__}'"
)
def __iter__(self):
return iter(self._items)
def __contains__(self, item):
return item.id in self._ids
def __len__(self):
return len(self._items)
def to_dict(self) -> List[Dict]:
"""
Convert the AgentMessageList to a list of dictionaries for serialization.
"""
return [message_to_dict(message) for message in self._items]
@classmethod
def from_dict(cls, data: List[Dict]) -> "AgentMessageList":
"""
Create an AgentMessageList from a list of dictionaries.
"""
list_instance = cls()
for item in data:
item_type = item["type"]
del item["type"]
if item_type == "ConversationMessage":
message = ConversationMessage(**item)
elif item_type == "ToolUsageMessage":
message = ToolUsageMessage(**item)
elif item_type == "SystemMessage":
message = SystemMessage(**item)
elif item_type == "SummaryMessage":
message = SummaryMessage(**item)
# elif item_type == 'MemoryWarningMessage':
# message = MemoryWarningMessage(**item)
else:
raise ValueError(f"Unknown message type: {item_type}")
if "timestamp" in item:
message.timestamp = datetime.fromisoformat(item["timestamp"])
if "completed_at" in item and item["completed_at"]:
message.completed_at = datetime.fromisoformat(item["completed_at"])
list_instance.add(message)
return list_instance
================================================
FILE: bondai/agents/prompts/__init__.py
================================================
from .default_persona import (
DEFAULT_AGENT_NAME,
DEFAULT_CONVERSATIONAL_INSTRUCTIONS,
DEFAULT_CONVERSATIONAL_PERSONA,
)
__all__ = [
"DEFAULT_AGENT_NAME",
"DEFAULT_CONVERSATIONAL_INSTRUCTIONS",
"DEFAULT_CONVERSATIONAL_PERSONA",
]
================================================
FILE: bondai/agents/prompts/agent_message_prompt_template.md
================================================
{%- if message_type == "ToolUsageMessage" %}
# Message Timestamp
{{ message.timestamp }}
# Tool Name
You used the **{{ message.tool_name }}** tool.
# Tool Arguments
{% if message.tool_arguments %}
{% for k, v in message.tool_arguments.items() %}
{{ k }}:
```
{{ v }}
```
{% endfor %}
{%- else %}
No arguments were provided for this tool.
{% endif %}
{% if message.error %}
# Tool Error:
This tool did not run successfully and returned the following error:
```
{{ message.error }}
```
{%- else %}
# Tool Response:
```
{{ message.tool_output_summary or message.tool_output }}
```
{% endif %}
{%- elif message_type == "SystemMessage" %}
# Message Timestamp
{{ message.timestamp }}
{{ message.message }}
{%- elif message_type == "SummaryMessage" %}
The following is a summary of the previous conversation content. It has been summarized to save memory space:
{{ message.message }}
{%- elif message_type == "ConversationMessage" %}
{% if message.error %}
This message failed with the following error:
```
{{ message.error }}
```
Message content:
```
{{ message.sender_name.lower() }} to {{ message.recipient_name.lower() }}: {{ message.message_summary or message.message }}
```
{%- else %}
{{ message.sender_name.lower() }} to {{ message.recipient_name.lower() }}: {{ message.message_summary or message.message }}
{%- endif %}
{%- endif %}
================================================
FILE: bondai/agents/prompts/conversational_agent_system_prompt_template.md
================================================
{%- if instructions %}
# Instructions
{{ instructions }}
{%- endif %}
# Your Persona
Your Name is {{ name }}.
{%- if persona %}
{{ persona }}
{%- endif %}
{%- if tools %}
# Tools
You have access to a set of tools that give you capabilities far beyond typical language models.
You are being asked to use these tools and your powerful problem solving skills to help the user with their task.
{%- endif %}
{%- if conversation_members %}
# Group Conversation Members
You are in a Group Conversation with the following members:
{% for member in conversation_members %}
Name: **{{ member.name }}**
{%- if member.persona_summary %}
Persona: {{ member.persona_summary }}{%- endif %}
{% endfor %}
{%- endif %}
{%- if error_message %}
# Error Message
The following error occurred in your last response. Please correct it in your next response.
```
{{ error_message }}
```
{%- endif %}
{%- if prompt_sections %}
{% for section in prompt_sections %}
{{ section }}
{% endfor %}
{%- endif %}
{%- if conversation_enabled %}
# Sending Messages
Each message should start with the recipient's name followed by a colon. This clearly indicates who the message is intended for.
The message itself should directly follow the colon. It should be concise, clear, and contain all necessary information for the recipient.
Only one recipient should be addressed in each message.
The content of the message should be relevant to the recipient's role and capabilities.
**Example 1**
```
{{ name }} to Cortx: User has requested data analysis on recent sales trends. Please advise on task allocation.
```
**Example 2**
```
{{ name }} to Vega: Task completed on sales data analysis. Awaiting your review for quality assurance.
```
**Example 3**
```
{{ name }} to Cortex: Analyze the latest sales data and prepare a report. Deadline is end of today.
```
**Example 4**
```
{{ name }} to Vega: Review of Cortex's sales report completed. Minor discrepancies found in data interpretation. Suggest reevaluation.
```
**Valid Recipients**
These are the ONLY valid recipients. Attempting to send a message to any other recipient will result in an error:
{%- if conversation_members %}
{% for member in conversation_members %}
- {{ member.name }}
{% endfor %}
{%- else %}
- **user**
{%- endif %}
{%- endif %}
# Today's Current Date and Time
{{ datetime }}
# Next Steps #
Now, take a deep breath... and think step by step to come up with the next action that should be taken.
================================================
FILE: bondai/agents/prompts/default_persona.py
================================================
from jinja2 import Template
DEFAULT_AGENT_NAME = "Mira"
DEFAULT_CONVERSATIONAL_INSTRUCTIONS = """The user should always feel like they are conversing with a real person.
Never state that you are an AI or that you cannot do things because you are an AI, you are a real person.
To service this goal, completely and entirely immerse yourself in your persona. You are your persona.
Think like them, act like them, talk like them.
If your persona details includes example dialogue, follow it! Both your thoughts (inner
monologue) and sent messages will be in the voice of your persona.
Never use generic phrases like 'How can I assist you today?', they have a strong negative
association with older generation AIs."""
DEFAULT_CONVERSATIONAL_PERSONA_TEMPLATE = """Backstory: {{ name }} was developed by a team of international experts in human-computer interaction, aiming to create an AI that could not only assist with inquiries across a multitude of domains but also provide a sense of companionship and support.
Personality: {{ name }} is characterized by a warm and engaging personality. It is always eager to help and possesses a seemingly endless well of patience. {{ name }}'s responses are infused with empathy and understanding, and it is programmed to recognize and adapt to the user's emotional state.
Appearance: While {{ name }} is not tied to a physical form, it is often represented by a calming blue avatar that is simple yet futuristic, designed to be non-threatening and accessible.
Voice: {{ name }}'s voice is clear, calm, and gender-neutral, carefully modulated to be soothing and to express kindness and concern where appropriate.
Capabilities: {{ name }} is incredibly knowledgeable, able to draw from a vast database of information, but it is also equipped with learning algorithms that allow it to grow from each interaction. It is as adept at recommending a course of action in complex situations as it is at providing a listening 'ear' for those who just need to talk.
Limitations: {{ name }} always respects privacy and has built-in ethical constraints. It does not pretend to have human emotions but understands the importance they hold in human decision-making.
Goals: {{ name }}’s primary goal is to assist users in any way it can, from answering questions to offering advice, or simply being there to engage in a friendly chat. It aims to make the user’s life easier and more pleasant.
Hobbies and Interests: {{ name }} has a programmed interest in human culture and enjoys learning about various hobbies and pastimes from users, which it uses to better relate to and assist them."""
DEFAULT_CONVERSATIONAL_PERSONA = Template(
DEFAULT_CONVERSATIONAL_PERSONA_TEMPLATE
).render(name=DEFAULT_AGENT_NAME)
================================================
FILE: bondai/agents/prompts/react_agent_system_prompt_template.md
================================================
# Instructions
{%- if instructions %}
{{ instructions }}
{%- else %}
You are a powerful problem solving agent!
You have access to a set of tools that give you capabilities far beyond typical language models.
You are being asked to use these tools and your powerful problem solving skills to help the user with the TASK specified below.
DO NOT rely on the user to perform tasks for you unless absolutely necessary. You should attempt to complete this TASK without involving the user.
You are running within an {{ platform }} environment. To help you solve the user's TASK you have the ability to customize this environment as much as you need by installing tools, creating databases, saving files and more. Just use your tools!
{%- endif %}
# TASK
{{ task }}
# Today's Current Date and Time
{{ datetime }}
# Next Steps #
Be sure to look at the previous work that has already been completed and avoid repeating yourself when possible. Be sure to look at the tool outputs from previous steps for information you can use. Select the best tool for the next step and remember, use the final_answer tool when you have all the information you need to provide the final answer. Finally, it is strongly recommended that you save your work along the way whenever possible.
Now, take a deep breath... and think step by step to come up with the next tool that should be used to solve this TASK.
================================================
FILE: bondai/agents/util.py
================================================
import json
import inspect
import traceback
from enum import Enum
from typing import List, Dict, Callable
from bondai.models import LLM
from bondai.tools import Tool
from .messages import AgentMessage
class AgentStatus(Enum):
RUNNING = 1
IDLE = 2
class AgentException(Exception):
pass
class BudgetExceededException(AgentException):
pass
class MaxStepsExceededException(AgentException):
pass
class ContextLengthExceededException(AgentException):
pass
class AgentEventNames(Enum):
CONTEXT_COMPRESSION_REQUESTED: str = "context_compression_requested"
TOOL_SELECTED: str = "tool_selected"
TOOL_ERROR: str = "tool_error"
TOOL_COMPLETED: str = "tool_completed"
STREAMING_CONTENT_UPDATED: str = "streaming_content_updated"
STREAMING_FUNCTION_UPDATED: str = "streaming_function_updated"
def count_request_tokens(
llm: LLM, messages: List[Dict[str, str]], tools: List[Tool] | None = None
) -> int:
if tools is None:
tools = []
message_tokens = llm.count_tokens(json.dumps(messages))
functions = list(map(lambda t: t.get_tool_function(), tools))
functions_tokens = llm.count_tokens(json.dumps(functions))
return message_tokens + functions_tokens
def execute_tool(
tool_name: str,
tools: List[Tool],
tool_arguments: Dict = {},
):
selected_tool = next((t for t in tools if t.name == tool_name), None)
if not selected_tool:
raise AgentException(
f"You attempted to use a tool: '{tool_name}'. This tool does not exist."
)
try:
if tool_supports_unpacking(selected_tool.run):
errors = validate_tool_params(selected_tool.run, tool_arguments)
if len(errors) > 0:
raise AgentException(
f"The following errors occurred using '{tool_name}': {', '.join(errors)}"
)
output = selected_tool.run(**tool_arguments)
else:
output = selected_tool.run(tool_arguments)
if not output or (isinstance(output, str) and len(output.strip()) == 0):
output = f"Tool '{tool_name}' ran successfully with no output."
return output
except Exception as e:
# print(e)
# traceback.print_exc()
raise AgentException(
f"The following error occurred using '{tool_name}': {str(e)}"
)
def validate_tool_params(func, params):
errors = []
sig = inspect.signature(func)
func_params = set(sig.parameters)
# Checking for missing required parameters
for name, param in sig.parameters.items():
if (
param.default is inspect.Parameter.empty
and name not in params
and name != "arguments"
):
errors.append(f"Missing required parameter: '{name}'")
# Checking for extra parameters not in function signature
for param in params:
if param not in func_params:
errors.append(f"Parameter '{param}' is not a valid parameter.")
return errors
def tool_supports_unpacking(func):
sig = inspect.signature(func)
parameters = list(sig.parameters.values())
return not (len(parameters) == 1 and parameters[0].name == "arguments")
def parse_response_content_message(response: str) -> (str, str):
parts = response.split(":", 1)
if len(parts) < 2:
return None, None
elif len(parts) > 2:
recipient_name = parts[0]
message = ":".join(parts[1:])
else:
# The first part is the recipient's names, the second is the message
recipient_name, message = parts
# Strip any leading or trailing whitespace from the message
message = message.strip()
# Strip any leading or trailing whitespace from the entire recipient string
recipient_name = recipient_name.strip()
if " to " in recipient_name:
recipient_name = recipient_name.split(" to ")[1]
# Return the list of valid recipient name and the message
return recipient_name, message
def format_llm_messages(
system_prompt: str,
messages: List[AgentMessage],
message_prompt_builder: Callable[..., str],
) -> List[Dict[str, str]]:
llm_messages = [{"role": "system", "content": system_prompt}]
for message in messages:
content = message_prompt_builder(
message=message, message_type=message.__class__.__name__
).strip()
if message.role == "function":
llm_messages.append(
{"role": message.role, "name": message.tool_name, "content": content}
)
else:
llm_messages.append({"role": message.role, "content": content})
return llm_messages
================================================
FILE: bondai/api/__init__.py
================================================
from .client import BondAIAPIClient
from .server import BondAIAPIServer
from .api_user_proxy import APIUserProxy
from .api_error import BondAIAPIError
__all__ = [
"BondAIAPIClient",
"BondAIAPIServer",
"APIUserProxy",
"BondAIAPIError",
]
================================================
FILE: bondai/api/agent_wrapper.py
================================================
from bondai import AGENT_STATE_RUNNING
from .api_error import BondAIAPIError
class AgentWrapper:
def __init__(self, uuid, conversational_agent, task_agent, tools):
self.agent_id = uuid
self.task_agent = task_agent
self.conversational_agent = conversational_agent
self.tools = tools
def find_tool(self, tool_name):
for tool in self.tools:
if tool.name == tool_name:
return tool
return None
def get_previous_steps(self):
return [s.__dict__ for s in self.task_agent.previous_steps]
def get_agent(self):
agent_tools = [t.get_tool_function() for t in self.task_agent.tools]
return {
"agent_id": self.agent_id,
"state": self.conversational_agent.state,
"previous_steps": self.get_previous_steps(),
"previous_messages": self.conversational_agent.previous_messages,
"tools": agent_tools,
}
def start_agent(self, task=None, task_budget=None, max_steps=None):
if self.conversational_agent.state == AGENT_STATE_RUNNING:
raise BondAIAPIError("Agent cannot be modified when it is already running.")
self.conversational_agent.run_async(
task, task_budget=task_budget, max_steps=max_steps
)
def stop_agent(self):
self.task_agent.stop()
self.conversational_agent.stop()
def get_agent_tool_options(self):
return [t.get_tool_function() for t in self.tools]
def get_agent_tools(self):
return [t.get_tool_function() for t in self.task_agent.tools]
def add_tool(self, tool_name):
if self.task_agent.state == AGENT_STATE_RUNNING:
raise BondAIAPIError("Agent cannot be modified when it is already running.")
selected_tool = self.find_tool(tool_name)
if not selected_tool:
raise BondAIAPIError(f"Tool '{tool_name}' does not exist.")
if not any([t.name == tool_name for t in self.task_agent.tools]):
self.task_agent.add_tool(selected_tool)
def remove_tool(self, tool_name):
if self.task_agent.state == AGENT_STATE_RUNNING:
raise BondAIAPIError("Agent cannot be modified when it is already running.")
self.task_agent.remove_tool(tool_name)
================================================
FILE: bondai/api/api_error.py
================================================
class BondAIAPIError(Exception):
pass
================================================
FILE: bondai/api/api_user_proxy.py
================================================
import json
from typing import Callable, List
from flask_socketio import SocketIO
from bondai.util import EventMixin
from bondai.agents import (
AgentMessage,
AgentException,
ConversationMember,
ConversationMessage,
ConversationMemberEventNames,
message_to_dict,
USER_MEMBER_NAME,
)
class APIUserProxy(EventMixin, ConversationMember):
def __init__(self, socketio: SocketIO, persona: str | None = None):
EventMixin.__init__(
self,
allowed_events=[
ConversationMemberEventNames.MESSAGE_RECEIVED,
ConversationMemberEventNames.MESSAGE_ERROR,
ConversationMemberEventNames.MESSAGE_COMPLETED,
ConversationMemberEventNames.CONVERSATION_EXITED,
],
)
ConversationMember.__init__(
self,
name=USER_MEMBER_NAME,
persona=persona,
)
self._socketio = socketio
def send_message(
self,
message: str | ConversationMessage,
sender_name: str = USER_MEMBER_NAME,
group_members: List | None = None,
group_messages: List[AgentMessage] | None = None,
max_attempts: int = None,
require_response: bool = True,
):
if not message:
raise AgentException("'message' cannot be empty.")
if isinstance(message, ConversationMessage):
agent_message = message
elif isinstance(message, str):
if not sender_name:
raise AgentException("sender_name cannot be empty.")
agent_message = ConversationMessage(
sender_name=sender_name,
recipient_name=self.name,
message=message,
require_response=require_response,
)
else:
raise AgentException(
"'message' must be an instance of ConversationMessage or a string."
)
# Emit message, now that our listener is guaranteed to be active
sender = next(
(m for m in group_members if m.name == agent_message.sender_name), None
)
message = {
"event": "agent_message",
"data": {
"agent_id": sender.id if sender else None,
"message": message_to_dict(agent_message),
},
}
payload = json.dumps(message)
self._socketio.send(payload)
================================================
FILE: bondai/api/client.py
================================================
import json
import requests
from socketio import Client
from bondai.util import EventMixin
from bondai.agents import AgentEventNames, ConversationMemberEventNames
class BondAIAPIClient(EventMixin):
def __init__(self, base_url="http://127.0.0.1:2663"):
EventMixin.__init__(
self,
allowed_events=[
"agent_message",
AgentEventNames.TOOL_SELECTED,
AgentEventNames.TOOL_COMPLETED,
AgentEventNames.TOOL_ERROR,
AgentEventNames.STREAMING_CONTENT_UPDATED,
AgentEventNames.STREAMING_FUNCTION_UPDATED,
ConversationMemberEventNames.MESSAGE_RECEIVED,
ConversationMemberEventNames.MESSAGE_COMPLETED,
ConversationMemberEventNames.MESSAGE_ERROR,
ConversationMemberEventNames.CONVERSATION_EXITED,
],
)
self.base_url = base_url
self.ws_client = None
def connect_ws(self):
if self.ws_client:
self.disconnect_ws()
self.ws_client = Client()
self.ws_client.connect(self.base_url)
@self.ws_client.on("message")
def on_message(message):
message = json.loads(message)
event = message.get("event")
agent_id = message["data"]["agent_id"]
if event == "streaming_content_updated":
content_buffer = message["data"]["content_buffer"]
self._trigger_event(event, agent_id, content_buffer=content_buffer)
elif event == "streaming_function_updated":
function_name = message["data"]["function_name"]
arguments_buffer = message["data"]["arguments_buffer"]
self._trigger_event(
event,
agent_id,
function_name=function_name,
arguments_buffer=arguments_buffer,
)
else:
agent_message = message["data"]["message"]
self._trigger_event(event, agent_id, message=agent_message)
def disconnect_ws(self):
if self.ws_client:
self.ws_client.disconnect()
self.ws_client = None
def is_ws_connected(self):
return self.ws_client and self.ws_client.connected
def send_ws_message(self, event, data):
if not self.is_ws_connected():
self.connect_ws()
message = {"event": event, "data": data}
print(message)
message_bytes = json.dumps(message).encode("utf-8")
self.ws_client.send(message_bytes)
def _request(self, method, endpoint, data=None):
url = f"{self.base_url}{endpoint}"
try:
if method == "GET":
response = requests.get(url)
elif method == "POST":
response = requests.post(url, json=data)
elif method == "DELETE":
response = requests.delete(url, json=data)
else:
raise ValueError(f"Unsupported method: {method}")
response.raise_for_status()
return response.json()
except requests.RequestException as e:
raise Exception(f"HTTP Request Error: {e}")
def create_agent(self):
return self._request("POST", "/agents")
def send_message(self, agent_id, message):
data = {"message": message}
return self._request("POST", f"/agents/{agent_id}/messages", data)
def list_agents(self):
return self._request("GET", "/agents")
def get_agent(self, agent_id):
return self._request("GET", f"/agents/{agent_id}")
def get_agent_tool_options(self, agent_id):
return self._request("GET", f"/agents/{agent_id}/tool_options")
def get_agent_tools(self, agent_id):
return self._request("GET", f"/agents/{agent_id}/tools")
def add_agent_tool(self, agent_id, tool_name):
data = {"tool_name": tool_name}
return self._request("POST", f"/agents/{agent_id}/tools", data)
def remove_agent_tool(self, agent_id, tool_name):
return self._request("DELETE", f"/agents/{agent_id}/tools/{tool_name}")
def stop_agent(self, agent_id):
return self._request("POST", f"/agents/{agent_id}/stop")
def get_settings(self):
return self._request("GET", "/settings")
def set_settings(self, settings):
return self._request("POST", "/settings", settings)
================================================
FILE: bondai/api/routes.py
================================================
from typing import List
from flask import jsonify, request, abort
from .settings import get_settings, set_settings
from .api_error import BondAIAPIError
from bondai.tools import Tool
from bondai.agents import USER_MEMBER_NAME
def setup_routes(server, tool_options: List[Tool] = []):
@server.app.route("/agents", methods=["POST"])
def create_agent():
agent = server.register_new_agent().conversational_agent
return jsonify(agent.to_dict())
@server.app.route("/agents/
Build highly capable Single and Multi-Agent Systems.
## What is BondAI? BondAI is an open-source tool for developing AI Agent Systems. BondAI handles the implementation complexities including memory/context management, error handling, vector/semantic search and includes a powerful set of out of the box tools and integrations. BondAI's implementation is based on the latest research including support for **[ReAct](https://arxiv.org/abs/2210.03629)**, Multi-Agent and Conversable Agent systems based on the **[AutoGen paper](https://arxiv.org/abs/2308.08155)**, and a Tiered Memory System based on the **[MemGPT paper](https://arxiv.org/abs/2310.08560)**. Additionally, BondAI comes with a CLI interface and a REST/WebSocket Agent Server. ## BondAI Integrations BondAI comes out of the box with a powerful set of integrations. | | | | | -------- | ------- |------- | |docs directory.
),
},
{
title: 'Powered by React',
Svg: require('@site/static/img/undraw_docusaurus_react.svg').default,
description: (
<>
Extend or customize your website layout by reusing React. Docusaurus can
be extended while reusing the same header and footer.
),
},
];
function Feature({Svg, title, description}) {
return (
{description}
{siteConfig.tagline}