Learn how to bring your own agents that work within a Crew.
def configure_tools
def configure_structured_output
BaseAgentAdapter
. This adapter acts as a compatibility layer, translating between the CrewAI interfaces and the specific requirements of your external agent.
Here’s how you implement your custom adapter:
BaseAgentAdapter
:
__init__
:
The constructor should call the parent class constructor super().__init__(**kwargs)
and perform any initialization specific to your external agent. You can use the optional agent_config
dictionary passed during CrewAI’s Agent
initialization to configure your adapter and the underlying agent.
configure_tools
:
This abstract method is crucial. It receives a list of CrewAI BaseTool
instances. Your implementation must convert or adapt these tools into the format expected by your external agent framework. This might involve wrapping them, extracting specific attributes, or registering them with the external agent instance.
configure_structured_output
:
This method is called when the CrewAI Agent
is configured with structured output requirements (e.g., output_json
or output_pydantic
). Your adapter needs to ensure the external agent is set up to comply with these requirements. This might involve setting specific parameters on the external agent or ensuring its underlying model supports the requested format. If the external agent doesn’t support structured output in a way compatible with CrewAI’s expectations, you might need to handle the conversion or raise an appropriate error.
MyCustomAgentAdapter
will allow your custom agent implementation to function correctly within a CrewAI crew, interacting with tasks and tools seamlessly. Remember to replace the example comments and print statements with your actual adaptation logic specific to the external agent framework you are integrating.
BaseToolAdapter
class is responsible for converting CrewAI’s native BaseTool
objects into a format that your specific external agent framework can understand and utilize. Different agent frameworks (like LangGraph, OpenAI Assistants, etc.) have their own unique ways of defining and handling tools, and the BaseToolAdapter
acts as the translator.
Here’s how you implement your custom tool adapter:
BaseToolAdapter
:
configure_tools
:
This is the core abstract method you must implement. It receives a list of CrewAI BaseTool
instances provided to the agent. Your task is to iterate through this list, adapt each BaseTool
into the format expected by your external framework, and store the converted tools in the self.converted_tools
list (which is initialized in the base class constructor).
MyCustomToolAdapter
within your MyCustomAgentAdapter
’s configure_tools
method and use it to process the tools before configuring your external agent.
BaseToolAdapter
, you decouple the tool conversion logic from the agent adaptation, making the integration cleaner and more modular. Remember to replace the placeholder examples with the actual conversion logic required by your specific external agent framework.
BaseConverterAdapter
plays a crucial role when a CrewAI Task
requires an agent to return its final output in a specific structured format, such as JSON or a Pydantic model. It bridges the gap between CrewAI’s structured output requirements and the capabilities of your external agent.
Its primary responsibilities are:
Task
’s requirements (output_json
or output_pydantic
), it instructs the associated BaseAgentAdapter
(and indirectly, the external agent) on what format is expected.BaseConverterAdapter
:
__init__
:
The constructor must accept the corresponding agent_adapter
instance it will work with.
configure_structured_output
:
This method receives the CrewAI Task
object. You need to check the task’s output_json
and output_pydantic
attributes to determine the required output structure. Store this information (e.g., in _output_type
and _output_schema
) and potentially call configuration methods on your self.agent_adapter
if the external agent needs specific setup for structured output (which might have been partially handled in the agent adapter’s configure_structured_output
already).
enhance_system_prompt
:
This method takes the agent’s base system prompt string and should append instructions tailored to the currently configured _output_type
and _output_schema
. The goal is to guide the LLM powering the agent to produce output in the correct format.
post_process_result
:
This method receives the raw string output from the agent. If structured output was requested (json
or pydantic
), you should attempt to parse the string into the expected format. Handle potential parsing errors (e.g., log them, attempt simple fixes, or raise an exception). Crucially, the method must always return a string, even if the intermediate format was a dictionary or Pydantic object (e.g., by serializing it back to a JSON string).
MyCustomConverterAdapter
ensures that structured output requests from CrewAI tasks are correctly handled by your integrated external agent, improving the reliability and usability of your custom agent within the CrewAI framework.