langroid
Main langroid package
Agent(config=AgentConfig())
¶
Bases: ABC
An Agent is an abstraction that encapsulates mainly two components:
- a language model (LLM)
- a vector store (vecdb)
plus associated components such as a parser, and variables that hold information about any tool/function-calling messages that have been defined.
Source code in langroid/agent/base.py
indent: str
property
writable
¶
Indentation to print before any responses from the agent's entities.
all_llm_tools_known: set[str]
property
¶
All known tools; this may extend self.llm_tools_known.
init_state()
¶
entity_responders()
¶
Sequence of (entity, response_method) pairs. This sequence is used
in a Task
to respond to the current pending message.
See Task.step()
for details.
Returns:
Sequence of (entity, response_method) pairs.
Source code in langroid/agent/base.py
entity_responders_async()
¶
Async version of entity_responders
. See there for details.
Source code in langroid/agent/base.py
enable_message_handling(message_class=None)
¶
Enable an agent to RESPOND (i.e. handle) a "tool" message of a specific type
from LLM. Also "registers" (i.e. adds) the message_class
to the
self.llm_tools_map
dict.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
message_class |
Optional[Type[ToolMessage]]
|
The message class to enable; Optional; if None, all known message classes are enabled for handling. |
None
|
Source code in langroid/agent/base.py
disable_message_handling(message_class=None)
¶
Disable a message class from being handled by this Agent.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
message_class |
Optional[Type[ToolMessage]]
|
The message class to disable. If None, all message classes are disabled. |
None
|
Source code in langroid/agent/base.py
sample_multi_round_dialog()
¶
Generate a sample multi-round dialog based on enabled message classes. Returns: str: The sample dialog string.
Source code in langroid/agent/base.py
create_agent_response(content=None, content_any=None, tool_messages=[], oai_tool_calls=None, oai_tool_choice='auto', oai_tool_id2result=None, function_call=None, recipient='')
¶
Template for agent_response.
Source code in langroid/agent/base.py
agent_response(msg=None)
¶
Response from the "agent itself", typically (but not only)
used to handle LLM's "tool message" or function_call
(e.g. OpenAI function_call
).
Args:
msg (str|ChatDocument): the input to respond to: if msg is a string,
and it contains a valid JSON-structured "tool message", or
if msg is a ChatDocument, and it contains a function_call
.
Returns:
Optional[ChatDocument]: the response, packaged as a ChatDocument
Source code in langroid/agent/base.py
process_tool_results(results, id2result, tool_calls=None)
¶
Process results from a response, based on whether they are results of OpenAI tool-calls from THIS agent, so that we can construct an appropriate LLMMessage that contains tool results.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
results |
str
|
A possible string result from handling tool(s) |
required |
id2result |
OrderedDict[str, str] | None
|
A dict of OpenAI tool id -> result, if there are multiple tool results. |
required |
tool_calls |
List[OpenAIToolCall] | None
|
List of OpenAI tool-calls that the results are a response to. |
None
|
Return
- str: The response string
- Dict[str,str]|None: A dict of OpenAI tool id -> result, if there are multiple tool results.
- str|None: tool_id if there was a single tool result
Source code in langroid/agent/base.py
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 |
|
response_template(e, content=None, content_any=None, tool_messages=[], oai_tool_calls=None, oai_tool_choice='auto', oai_tool_id2result=None, function_call=None, recipient='')
¶
Template for response from entity e
.
Source code in langroid/agent/base.py
create_user_response(content=None, content_any=None, tool_messages=[], oai_tool_calls=None, oai_tool_choice='auto', oai_tool_id2result=None, function_call=None, recipient='')
¶
Template for user_response.
Source code in langroid/agent/base.py
user_response(msg=None)
¶
Get user response to current message. Could allow (human) user to intervene with an actual answer, or quit using "q" or "x"
Parameters:
Name | Type | Description | Default |
---|---|---|---|
msg |
str | ChatDocument
|
the string to respond to. |
None
|
Returns:
Type | Description |
---|---|
Optional[ChatDocument]
|
(str) User response, packaged as a ChatDocument |
Source code in langroid/agent/base.py
llm_can_respond(message=None)
¶
Whether the LLM can respond to a message. Args: message (str|ChatDocument): message or ChatDocument object to respond to.
Returns:
Source code in langroid/agent/base.py
can_respond(message=None)
¶
Whether the agent can respond to a message. Used in Task.py to skip a sub-task when we know it would not respond. Args: message (str|ChatDocument): message or ChatDocument object to respond to.
Source code in langroid/agent/base.py
create_llm_response(content=None, content_any=None, tool_messages=[], oai_tool_calls=None, oai_tool_choice='auto', oai_tool_id2result=None, function_call=None, recipient='')
¶
Template for llm_response.
Source code in langroid/agent/base.py
llm_response_async(message=None)
async
¶
Asynch version of llm_response
. See there for details.
Source code in langroid/agent/base.py
llm_response(message=None)
¶
LLM response to a prompt. Args: message (str|ChatDocument): prompt string, or ChatDocument object
Returns:
Type | Description |
---|---|
Optional[ChatDocument]
|
Response from LLM, packaged as a ChatDocument |
Source code in langroid/agent/base.py
has_tool_message_attempt(msg)
¶
Check whether msg contains a Tool/fn-call attempt (by the LLM).
CAUTION: This uses self.get_tool_messages(msg) which as a side-effect may update msg.tool_messages when msg is a ChatDocument, if there are any tools in msg.
Source code in langroid/agent/base.py
has_only_unhandled_tools(msg)
¶
Does the msg have at least one tool, and ALL tools are disabled for handling by this agent?
Source code in langroid/agent/base.py
get_tool_messages(msg, all_tools=False)
¶
Get ToolMessages recognized in msg, handle-able by this agent. NOTE: as a side-effect, this will update msg.tool_messages when msg is a ChatDocument and msg contains tool messages. The intent here is that update=True should be set ONLY within agent_response() or agent_response_async() methods. In other words, we want to persist the msg.tool_messages only AFTER the agent has had a chance to handle the tools.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
msg |
str | ChatDocument
|
the message to extract tools from. |
required |
all_tools |
bool
|
|
False
|
Returns:
Type | Description |
---|---|
List[ToolMessage]
|
List[ToolMessage]: list of ToolMessage objects |
Source code in langroid/agent/base.py
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 |
|
get_formatted_tool_messages(input_str)
¶
Returns ToolMessage objects (tools) corresponding to tool-formatted substrings, if any. ASSUMPTION - These tools are either ALL JSON-based, or ALL XML-based (i.e. not a mix of both). Terminology: a "formatted tool msg" is one which the LLM generates as part of its raw string output, rather than within a JSON object in the API response (i.e. this method does not extract tools/fns returned by OpenAI's tools/fns API or similar APIs).
Parameters:
Name | Type | Description | Default |
---|---|---|---|
input_str |
str
|
input string, typically a message sent by an LLM |
required |
Returns:
Type | Description |
---|---|
List[ToolMessage]
|
List[ToolMessage]: list of ToolMessage objects |
Source code in langroid/agent/base.py
get_function_call_class(msg)
¶
From ChatDocument (constructed from an LLM Response), get the ToolMessage
corresponding to the function_call
if it exists.
Source code in langroid/agent/base.py
get_oai_tool_calls_classes(msg)
¶
From ChatDocument (constructed from an LLM Response), get
a list of ToolMessages corresponding to the tool_calls
, if any.
Source code in langroid/agent/base.py
tool_validation_error(ve)
¶
Handle a validation error raised when parsing a tool message, when there is a legit tool name used, but it has missing/bad fields. Args: tool (ToolMessage): The tool message that failed validation ve (ValidationError): The exception raised
Returns:
Name | Type | Description |
---|---|---|
str |
str
|
The error message to send back to the LLM |
Source code in langroid/agent/base.py
handle_message(msg)
¶
Handle a "tool" message either a string containing one or more
valid "tool" JSON substrings, or a
ChatDocument containing a function_call
attribute.
Handle with the corresponding handler method, and return
the results as a combined string.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
msg |
str | ChatDocument
|
The string or ChatDocument to handle |
required |
Returns:
Type | Description |
---|---|
None | str | OrderedDict[str, str] | ChatDocument
|
The result of the handler method can be:
- None if no tools successfully handled, or no tools present
- str if langroid-native JSON tools were handled, and results concatenated,
OR there's a SINGLE OpenAI tool-call.
(We do this so the common scenario of a single tool/fn-call
has a simple behavior).
- Dict[str, str] if multiple OpenAI tool-calls were handled
(dict is an id->result map)
- ChatDocument if a handler returned a ChatDocument, intended to be the
final response of the |
Source code in langroid/agent/base.py
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 |
|
handle_message_fallback(msg)
¶
Fallback method for the "no-tools" scenario. This method can be overridden by subclasses, e.g., to create a "reminder" message when a tool is expected but the LLM "forgot" to generate one.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
msg |
str | ChatDocument
|
The input msg to handle |
required |
Returns: Any: The result of the handler method
Source code in langroid/agent/base.py
to_ChatDocument(msg, orig_tool_name=None, chat_doc=None, author_entity=Entity.AGENT)
¶
Convert result of a responder (agent_response or llm_response, or task.run()), or tool handler, or handle_message_fallback, to a ChatDocument, to enable handling by other responders/tasks in a task loop possibly involving multiple agents.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
msg |
Any
|
The result of a responder or tool handler or task.run() |
required |
orig_tool_name |
str
|
The original tool name that generated the response, if any. |
None
|
chat_doc |
ChatDocument
|
The original ChatDocument object that |
None
|
author_entity |
Entity
|
The intended author of the result ChatDocument |
AGENT
|
Source code in langroid/agent/base.py
from_ChatDocument(msg, output_type)
¶
Extract a desired output_type from a ChatDocument object.
We use this fallback order:
- if msg.content_any
exists and matches the output_type, return it
- if msg.content
exists and output_type is str return it
- if output_type is a ToolMessage, return the first tool in msg.tool_messages
- if output_type is a list of ToolMessage,
return all tools in msg.tool_messages
- search for a tool in msg.tool_messages
that has a field of output_type,
and if found, return that field value
- return None if all the above fail
Source code in langroid/agent/base.py
handle_tool_message(tool, chat_doc=None)
¶
Respond to a tool request from the LLM, in the form of an ToolMessage object.
Args:
tool: ToolMessage object representing the tool request.
chat_doc: Optional ChatDocument object containing the tool request.
This is passed to the tool-handler method only if it has a chat_doc
argument.
Returns:
Source code in langroid/agent/base.py
update_token_usage(response, prompt, stream, chat=True, print_response_stats=True)
¶
Updates response.usage
obj (token usage and cost fields).the usage memebr
It updates the cost after checking the cache and updates the
tokens (prompts and completion) if the response stream is True, because OpenAI
doesn't returns these fields.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
response |
LLMResponse
|
LLMResponse object |
required |
prompt |
str | List[LLMMessage]
|
prompt or list of LLMMessage objects |
required |
stream |
bool
|
whether to update the usage in the response object if the response is not cached. |
required |
chat |
bool
|
whether this is a chat model or a completion model |
True
|
print_response_stats |
bool
|
whether to print the response stats |
True
|
Source code in langroid/agent/base.py
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 |
|
ask_agent(agent, request, no_answer=NO_ANSWER, user_confirm=True)
¶
Send a request to another agent, possibly after confirming with the user.
This is not currently used, since we rely on the task loop and
RecipientTool
to address requests to other agents. It is generally best to
avoid using this method.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
agent |
Agent
|
agent to ask |
required |
request |
str
|
request to send |
required |
no_answer |
str
|
expected response when agent does not know the answer |
NO_ANSWER
|
user_confirm |
bool
|
whether to gate the request with a human confirmation |
True
|
Returns:
Name | Type | Description |
---|---|---|
str |
Optional[str]
|
response from agent |
Source code in langroid/agent/base.py
AgentConfig
¶
Bases: BaseSettings
General config settings for an LLM agent. This is nested, combining configs of various components.
StatusCode
¶
Bases: str
, Enum
Codes meant to be returned by task.run(). Some are not used yet.
ChatDocument(**data)
¶
Bases: Document
Represents a message in a conversation among agents. All responders of an agent have signature ChatDocument -> ChatDocument (modulo None, str, etc), and so does the Task.run() method.
Attributes:
Name | Type | Description |
---|---|---|
oai_tool_calls |
Optional[List[OpenAIToolCall]]
|
Tool-calls from an OpenAI-compatible API |
oai_tool_id2results |
Optional[OrderedDict[str, str]]
|
Results of tool-calls from OpenAI (dict is a map of tool_id -> result) |
oai_tool_choice |
ToolChoiceTypes | Dict[str, Dict[str, str] | str]
|
ToolChoiceTypes | Dict[str, str]: Param controlling how the LLM should choose tool-use in its response (auto, none, required, or a specific tool) |
function_call |
Optional[LLMFunctionCall]
|
Function-call from an OpenAI-compatible API (deprecated by OpenAI, in favor of tool-calls) |
tool_messages |
List[ToolMessage]
|
Langroid ToolMessages extracted from
- |
metadata |
ChatDocMetaData
|
Metadata for the message, e.g. sender, recipient. |
attachment |
None | ChatDocAttachment
|
Any additional data attached. |
Source code in langroid/agent/chat_document.py
delete_id(id)
staticmethod
¶
Remove ChatDocument with given id from ObjectRegistry, and all its descendants.
Source code in langroid/agent/chat_document.py
get_tool_names()
¶
Get names of attempted tool usages (JSON or non-JSON) in the content
of the message.
Returns:
List[str]: list of attempted tool names
(We say "attempted" since we ONLY look at the request
component of the
tool-call representation, and we're not fully parsing it into the
corresponding tool message class)
Source code in langroid/agent/chat_document.py
log_fields()
¶
Fields for logging in csv/tsv logger Returns: List[str]: list of fields
Source code in langroid/agent/chat_document.py
pop_tool_ids()
¶
from_LLMResponse(response, displayed=False)
staticmethod
¶
Convert LLMResponse to ChatDocument. Args: response (LLMResponse): LLMResponse to convert. displayed (bool): Whether this response was displayed to the user. Returns: ChatDocument: ChatDocument representation of this LLMResponse.
Source code in langroid/agent/chat_document.py
to_LLMMessage(message, oai_tools=None)
staticmethod
¶
Convert to list of LLMMessage, to incorporate into msg-history sent to LLM API. Usually there will be just a single LLMMessage, but when the ChatDocument contains results from multiple OpenAI tool-calls, we would have a sequence LLMMessages, one per tool-call result.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
message |
str | ChatDocument
|
Message to convert. |
required |
oai_tools |
Optional[List[OpenAIToolCall]]
|
Tool-calls currently awaiting response, from the ChatAgent's latest message. |
None
|
Returns: List[LLMMessage]: list of LLMMessages corresponding to this ChatDocument.
Source code in langroid/agent/chat_document.py
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 |
|
ToolMessage
¶
Bases: ABC
, BaseModel
Abstract Class for a class that defines the structure of a "Tool" message from an LLM. Depending on context, "tools" are also referred to as "plugins", or "function calls" (in the context of OpenAI LLMs). Essentially, they are a way for the LLM to express its intent to run a special function or method. Currently these "tools" are handled by methods of the agent.
Attributes:
Name | Type | Description |
---|---|---|
request |
str
|
name of agent method to map to. |
purpose |
str
|
purpose of agent method, expressed in general terms. (This is used when auto-generating the tool instruction to the LLM) |
examples()
classmethod
¶
Examples to use in few-shot demos with formatting instructions. Each example can be either: - just a ToolMessage instance, e.g. MyTool(param1=1, param2="hello"), or - a tuple (description, ToolMessage instance), where the description is a natural language "thought" that leads to the tool usage, e.g. ("I want to find the square of 5", SquareTool(num=5)) In some scenarios, including such a description can significantly enhance reliability of tool use. Returns:
Source code in langroid/agent/tool_message.py
usage_examples(random=False)
classmethod
¶
Instruction to the LLM showing examples of how to use the tool-message.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
random |
bool
|
whether to pick a random example from the list of examples.
Set to |
False
|
Returns: str: examples of how to use the tool/function-call
Source code in langroid/agent/tool_message.py
get_value_of_type(target_type)
¶
Try to find a value of a desired type in the fields of the ToolMessage.
Source code in langroid/agent/tool_message.py
default_value(f)
classmethod
¶
Returns the default value of the given field, for the message-class Args: f (str): field name
Returns:
Name | Type | Description |
---|---|---|
Any |
Any
|
default value of the field, or None if not set or if the field does not exist. |
Source code in langroid/agent/tool_message.py
format_instructions(tool=False)
classmethod
¶
Default Instructions to the LLM showing how to use the tool/function-call. Works for GPT4 but override this for weaker LLMs if needed.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
tool |
bool
|
instructions for Langroid-native tool use? (e.g. for non-OpenAI LLM) (or else it would be for OpenAI Function calls). Ignored in the default implementation, but can be used in subclasses. |
False
|
Returns: str: instructions on how to use the message
Source code in langroid/agent/tool_message.py
group_format_instructions()
staticmethod
¶
Template for instructions for a group of tools. Works with GPT4 but override this for weaker LLMs if needed.
Source code in langroid/agent/tool_message.py
llm_function_schema(request=False, defaults=True)
classmethod
¶
Clean up the schema of the Pydantic class (which can recursively contain other Pydantic classes), to create a version compatible with OpenAI Function-call API.
Adapted from this excellent library: https://github.com/jxnl/instructor/blob/main/instructor/function_calls.py
Parameters:
Name | Type | Description | Default |
---|---|---|---|
request |
bool
|
whether to include the "request" field in the schema. (we set this to True when using Langroid-native TOOLs as opposed to OpenAI Function calls) |
False
|
defaults |
bool
|
whether to include fields with default values in the schema, in the "properties" section. |
True
|
Returns:
Name | Type | Description |
---|---|---|
LLMFunctionSpec |
LLMFunctionSpec
|
the schema as an LLMFunctionSpec |
Source code in langroid/agent/tool_message.py
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 |
|
simple_schema()
classmethod
¶
Return a simplified schema for the message, with only the request and required fields. Returns: Dict[str, Any]: simplified schema
Source code in langroid/agent/tool_message.py
ChatAgent(config=ChatAgentConfig(), task=None)
¶
Bases: Agent
Chat Agent interacting with external env
(could be human, or external tools).
The agent (the LLM actually) is provided with an optional "Task Spec",
which is a sequence of LLMMessage
s. These are used to initialize
the task_messages
of the agent.
In most applications we will use a ChatAgent
rather than a bare Agent
.
The Agent
class mainly exists to hold various common methods and attributes.
One difference between ChatAgent
and Agent
is that ChatAgent
's
llm_response
method uses "chat mode" API (i.e. one that takes a
message sequence rather than a single message),
whereas the same method in the Agent
class uses "completion mode" API (i.e. one
that takes a single message).
config: settings for the agent
Source code in langroid/agent/chat_agent.py
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 |
|
task_messages: List[LLMMessage]
property
¶
The task messages are the initial messages that define the task of the agent. There will be at least a system message plus possibly a user msg. Returns: List[LLMMessage]: the task messages
all_llm_tools_known: set[str]
property
¶
All known tools; we include output_format
if it is a ToolMessage
.
init_state()
¶
Initialize the state of the agent. Just conversation state here, but subclasses can override this to initialize other state.
Source code in langroid/agent/chat_agent.py
from_id(id)
staticmethod
¶
Get an agent from its ID Args: agent_id (str): ID of the agent Returns: ChatAgent: The agent with the given ID
clone(i=0)
¶
Create i'th clone of this agent, ensuring tool use/handling is cloned. Important: We assume all member variables are in the init method here and in the Agent class. TODO: We are attempting to clone an agent after its state has been changed in possibly many ways. Below is an imperfect solution. Caution advised. Revisit later.
Source code in langroid/agent/chat_agent.py
clear_history(start=-2)
¶
Clear the message history, starting at the index start
Parameters:
Name | Type | Description | Default |
---|---|---|---|
start |
int
|
index of first message to delete; default = -2 (i.e. delete last 2 messages, typically these are the last user and assistant messages) |
-2
|
Source code in langroid/agent/chat_agent.py
update_history(message, response)
¶
Update the message history with the latest user message and LLM response. Args: message (str): user message response: (str): LLM response
Source code in langroid/agent/chat_agent.py
tool_format_rules()
¶
Specification of tool formatting rules
(typically JSON-based but can be non-JSON, e.g. XMLToolMessage),
based on the currently enabled usable ToolMessage
s
Returns:
Name | Type | Description |
---|---|---|
str |
str
|
formatting rules |
Source code in langroid/agent/chat_agent.py
tool_instructions()
¶
Instructions for tools or function-calls, for enabled and usable Tools. These are inserted into system prompt regardless of whether we are using our own ToolMessage mechanism or the LLM's function-call mechanism.
Returns:
Name | Type | Description |
---|---|---|
str |
str
|
concatenation of instructions for all usable tools |
Source code in langroid/agent/chat_agent.py
augment_system_message(message)
¶
Augment the system message with the given message. Args: message (str): system message
last_message_with_role(role)
¶
from message_history
, return the last message with role role
Source code in langroid/agent/chat_agent.py
nth_message_idx_with_role(role, n)
¶
Index of n
th message in message_history, with specified role.
(n is assumed to be 1-based, i.e. 1 is the first message with that role).
Return -1 if not found. Index = 0 is the first message in the history.
Source code in langroid/agent/chat_agent.py
update_last_message(message, role=Role.USER)
¶
Update the last message that has role role
in the message history.
Useful when we want to replace a long user prompt, that may contain context
documents plus a question, with just the question.
Args:
message (str): new message to replace with
role (str): role of message to replace
Source code in langroid/agent/chat_agent.py
unhandled_tools()
¶
The set of tools that are known but not handled. Useful in task flow: an agent can refuse to accept an incoming msg when it only has unhandled tools.
Source code in langroid/agent/chat_agent.py
enable_message(message_class, use=True, handle=True, force=False, require_recipient=False, include_defaults=True)
¶
Add the tool (message class) to the agent, and enable either - tool USE (i.e. the LLM can generate JSON to use this tool), - tool HANDLING (i.e. the agent can handle JSON from this tool),
Parameters:
Name | Type | Description | Default |
---|---|---|---|
message_class |
Optional[Type[ToolMessage] | List[Type[ToolMessage]]]
|
The ToolMessage class OR List of such classes to enable, for USE, or HANDLING, or both. If this is a list of ToolMessage classes, then the remain args are applied to all classes. Optional; if None, then apply the enabling to all tools in the agent's toolset that have been enabled so far. |
required |
use |
bool
|
IF True, allow the agent (LLM) to use this tool (or all tools), else disallow |
True
|
handle |
bool
|
if True, allow the agent (LLM) to handle (i.e. respond to) this tool (or all tools) |
True
|
force |
bool
|
whether to FORCE the agent (LLM) to USE the specific
tool represented by |
False
|
require_recipient |
bool
|
whether to require that recipient be specified
when using the tool message (only applies if |
False
|
include_defaults |
bool
|
whether to include fields that have default values, in the "properties" section of the JSON format instructions. (Normally the OpenAI completion API ignores these fields, but the Assistant fn-calling seems to pay attn to these, and if we don't want this, we should set this to False.) |
True
|
Source code in langroid/agent/chat_agent.py
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 |
|
set_output_format(output_type, force_tools=None, use=None, handle=None, instructions=None, is_copy=False)
¶
Sets output_format
to output_type
and, if force_tools
is enabled,
switches to the native Langroid tools mechanism to ensure that no tool
calls not of output_type
are generated. By default, force_tools
follows the use_tools_on_output_format
parameter in the config.
If output_type
is None, restores to the state prior to setting
output_format
.
If use
, we enable use of output_type
when it is a subclass
of ToolMesage
. Note that this primarily controls instruction
generation: the model will always generate output_type
regardless
of whether use
is set. Defaults to the use_output_format
parameter in the config. Similarly, handling of output_type
is
controlled by handle
, which defaults to the
handle_output_format
parameter in the config.
instructions
controls whether we generate instructions specifying
the output format schema. Defaults to the instructions_output_format
parameter in the config.
is_copy
is set when called via __getitem__
. In that case, we must
copy certain fields to ensure that we do not overwrite the main agent's
setings.
Source code in langroid/agent/chat_agent.py
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 |
|
disable_message_handling(message_class=None)
¶
Disable this agent from RESPONDING to a message_class
(Tool). If
message_class
is None, then disable this agent from responding to ALL.
Args:
message_class: The ToolMessage class to disable; Optional.
Source code in langroid/agent/chat_agent.py
disable_message_use(message_class)
¶
Disable this agent from USING a message class (Tool).
If message_class
is None, then disable this agent from USING ALL tools.
Args:
message_class: The ToolMessage class to disable.
If None, disable all.
Source code in langroid/agent/chat_agent.py
disable_message_use_except(message_class)
¶
Disable this agent from USING ALL messages EXCEPT a message class (Tool) Args: message_class: The only ToolMessage class to allow
Source code in langroid/agent/chat_agent.py
get_tool_messages(msg, all_tools=False)
¶
Extracts messages and tracks whether any errors occured. If strict mode was enabled, disables it for the tool, else triggers strict recovery.
Source code in langroid/agent/chat_agent.py
truncate_message(idx, tokens=5, warning='...[Contents truncated!]')
¶
Truncate message at idx in msg history to tokens
tokens
Source code in langroid/agent/chat_agent.py
llm_response(message=None)
¶
Respond to a single user message, appended to the message history, in "chat" mode Args: message (str|ChatDocument): message or ChatDocument object to respond to. If None, use the self.task_messages Returns: LLM response as a ChatDocument object
Source code in langroid/agent/chat_agent.py
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 |
|
llm_response_async(message=None)
async
¶
Async version of llm_response
. See there for details.
Source code in langroid/agent/chat_agent.py
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 |
|
init_message_history()
¶
Initialize the message history with the system message and user message
Source code in langroid/agent/chat_agent.py
llm_response_messages(messages, output_len=None, tool_choice='auto')
¶
Respond to a series of messages, e.g. with OpenAI ChatCompletion Args: messages: seq of messages (with role, content fields) sent to LLM output_len: max number of tokens expected in response. If None, use the LLM's default max_output_tokens. Returns: Document (i.e. with fields "content", "metadata")
Source code in langroid/agent/chat_agent.py
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 |
|
llm_response_messages_async(messages, output_len=None, tool_choice='auto')
async
¶
Async version of llm_response_messages
. See there for details.
Source code in langroid/agent/chat_agent.py
llm_response_forget(message)
¶
LLM Response to single message, and restore message_history. In effect a "one-off" message & response that leaves agent message history state intact.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
message |
str
|
user message |
required |
Returns:
Type | Description |
---|---|
ChatDocument
|
A Document object with the response. |
Source code in langroid/agent/chat_agent.py
llm_response_forget_async(message)
async
¶
Async version of llm_response_forget
. See there for details.