gpt multi atomic agents
1.0.0
Un marco dinámico simple de múltiples agentes basado en agentes atómicos e Instructor. Utiliza el poder de Pydantic para la validación y serialización de datos y esquemas.
componer agentes hechos a partir de un indicador del sistema, con un lenguaje compartido de llamadas a funciones o mutaciones GraphQL
un enrutador utiliza un LLM para procesar solicitudes de usuario 'compuestas' complejas y enrutarlas automáticamente a la mejor secuencia de sus agentes
generar a través de OpenAI o AWS Bedrock o groq
nota: el !! framework is at an early stage !! - Los cambios importantes se indicarán aumentando la versión menor (la mayor todavía está en cero).
Un marco de agentes basado en LLM que utiliza un enfoque de programación orientada a agentes para orquestar agentes utilizando un lenguaje compartido.
El lenguaje del agente puede estar basado en llamadas a funciones o en GraphQL .
El marco es genérico y permite definir agentes en términos de nombre, descripción, llamadas de entrada aceptadas y llamadas de salida permitidas.
Los agentes se comunican indirectamente mediante una pizarra. El lenguaje está compuesto por llamadas (función o mutación GraphQL): cada agente especifica lo que entiende como entrada y qué llamadas puede generar. De esta manera, los agentes pueden comprender la producción de los demás.
Un enrutador toma el mensaje del usuario y genera un plan de ejecución del agente.
El plan de ejecución utiliza la mejor secuencia de los agentes más adecuados para manejar la solicitud del usuario.
El enrutador reescribe el mensaje del usuario para adaptarlo a cada agente, lo que mejora la calidad y evita resultados no deseados.
Nota: Opcionalmente, el enrutador se puede ejecutar por separado, lo que permite la retroalimentación humana sobre el plan de ejecución que generó el enrutador. De esta forma, el usuario puede colaborar más con el enrutador, antes de que se ejecuten realmente los agentes generativos.
Finalmente, la salida se devuelve en forma de una lista ordenada de llamadas (Función o GraphQL).
Para leer más sobre este enfoque, puede ver este artículo de Medium.
framework is at an early stage . El Evaluador no está implementado actualmente. Al realizar la integración, según el tipo de Definiciones de agente que se utilicen, el cliente debe:
Esta es una demostración del constructor de mundos 'Sim Life'. Utiliza 3 agentes (Creature Creature, Vegetation Creator, Relationship Creator) para procesar las indicaciones de los usuarios. Los agentes se definen en términos de funciones. El resultado es una serie de llamadas a funciones que el cliente puede implementar para construir el mundo de Sim Life.
La función AgregarCreatura:
function_add_creature = FunctionSpecSchema (
agent_name = creature_agent_name ,
function_name = "AddCreature" ,
description = "Adds a new creature to the world (not vegetation)" ,
parameters = [
ParameterSpec ( name = "creature_name" , type = ParameterType . string ),
ParameterSpec ( name = "allowed_terrain" , type = ParameterType . string , allowed_values = terrain_types ),
ParameterSpec ( name = "age" , type = ParameterType . int ),
ParameterSpec ( name = "icon_name" , type = ParameterType . string , allowed_values = creature_icons ),
]
)La función AddCreatureRelationship:
function_add_relationship = FunctionSpecSchema (
agent_name = relationship_agent_name ,
function_name = "AddCreatureRelationship" ,
description = "Adds a new relationship between two creatures" ,
parameters = [
ParameterSpec (
name = "from_name" , type = ParameterType . string
),
ParameterSpec (
name = "to_name" , type = ParameterType . string
),
ParameterSpec (
name = "relationship_name" ,
type = ParameterType . string ,
allowed_values = [ "eats" , "buys" , "feeds" , "sells" ],
),
],
)El agente Creature Creator se define declarativamente en términos de:
Los agentes pueden colaborar e intercambiar información indirectamente, reutilizando las mismas definiciones de funciones a través de una pizarra.
def build_creature_agent ():
agent_definition = FunctionAgentDefinition (
agent_name = "Creature Creator" ,
description = "Creates new creatures given the user prompt. Ensures that ALL creatures mentioned by the user are created." ,
accepted_functions = [ function_add_creature , function_add_relationship ],
input_schema = FunctionAgentInputSchema ,
initial_input = FunctionAgentInputSchema (
functions_allowed_to_generate = [ function_add_creature ],
previously_generated_functions = []
),
output_schema = FunctionAgentOutputSchema ,
topics = [ "creature" ]
)
return agent_definitionNotas sobre el agente Creature Creator:
function_add_relationship . Consulte el código fuente de ejemplo para obtener más detalles. Esta es una demostración del constructor de mundos 'Sim Life'. Utiliza 3 agentes (Creature Creature, Vegetation Creator, Relationship Creator) para procesar las indicaciones de los usuarios. Los agentes se definen de forma declarativa en términos del esquema de entrada GraphQL y se permiten mutaciones generadas. El resultado es una serie de mutaciones GraphQL que el cliente puede ejecutar para construir el mundo de Sim Life.
El esquema GraphQL:
type Creature {
id : ID !
creature_name : String !
allowed_terrain : TerrainType !
age : Int !
icon_name : IconType !
}
type Vegetation {
id : ID !
vegetation_name : String !
icon_name : IconType !
allowed_terrain : TerrainType !
}
type Relationship {
id : ID !
from_name : String !
to_name : String !
relationship_kind : RelationshipType !
}
...Las mutaciones GraphQL que queremos que generen los Agentes son distintas para cada agente:
Agente creador de criaturas:
type Mutation {
addCreature ( input : CreatureInput ! ): Creature !
}
input CreatureInput {
creature_name : String !
allowed_terrain : TerrainType !
age : Int !
icon_name : IconType !
}Agente creador de vegetación:
type Mutation {
addVegetation ( input : VegetationInput ! ): Vegetation !
}
input VegetationInput {
vegetation_name : String !
icon_name : IconType !
allowed_terrain : TerrainType !
}El agente Creature Creator se define declarativamente en términos de:
Un agente es básicamente una composición de esquemas de entrada y salida, junto con un mensaje.
Los agentes colaboran e intercambian información indirectamente a través de una pizarra, reutilizando los mismos esquemas GraphQL y llamadas de mutación.
creatures_graphql = _read_schema ( "creature.graphql" )
creature_mutations_graphql = _read_schema ( "creature.mutations.graphql" )
def build_creature_agent ():
agent_definition = GraphQLAgentDefinition (
agent_name = "Creature Creator" ,
description = "Creates new creatures given the user prompt. Ensures that ALL creatures mentioned by the user are created." ,
accepted_graphql_schemas = [ creatures_graphql , creature_mutations_graphql ],
input_schema = GraphQLAgentInputSchema ,
initial_input = GraphQLAgentInputSchema (
mutations_allowed_to_generate = [ creature_mutations_graphql ],
previously_generated_mutations = []
),
output_schema = GraphQLAgentOutputSchema ,
topics = [ "creature" ]
)
return agent_definitionNotas sobre este agente:
creature_mutations_graphql del archivo "creature.mutations.graphql".creature_mutations_graphql ).creatures_graphql en el archivo "creature.graphql".Los agentes se pueden utilizar juntos para formar un chat bot:
from gpt_multi_atomic_agents import functions_expert_service , config
from . import agents
def run_chat_loop ( given_user_prompt : str | None = None ) -> list :
CHAT_AGENT_DESCRIPTION = "Handles users questions about an ecosystem game like Sim Life"
agent_definitions = [
build_creature_agent (), build_relationship_agent (), build_vegatation_agent () # for more capabilities, add more agents here
]
_config = config . Config (
ai_platform = config . AI_PLATFORM_Enum . bedrock_anthropic ,
model = config . ANTHROPIC_MODEL ,
max_tokens = config . ANTHROPIC_MAX_TOKENS ,
is_debug = False
)
return functions_expert_service . run_chat_loop ( agent_definitions = agent_definitions , chat_agent_description = CHAT_AGENT_DESCRIPTION , _config = _config , given_user_prompt = given_user_prompt )nota: si no se
given_user_prompt, entoncesrun_chat_loop()esperará la entrada del usuario desde el teclado
Consulte el código fuente de ejemplo para obtener más detalles.
ENTRADA DEL USUARIO:
Add a sheep that eats grass
PRODUCCIÓN:
Generated 3 function calls
[Agent: Creature Creator] AddCreature( creature_name=sheep, icon_name=sheep-icon, land_type=prairie, age=1 )
[Agent: Plant Creator] AddPlant( plant_name=grass, icon_name=grass-icon, land_type=prairie )
[Agent: Relationship Creator] AddCreatureRelationship( from_name=sheep, to_name=grass, relationship_name=eats )
Debido a que el marco tiene un enrutador dinámico, puede manejar solicitudes 'compuestas' más complejas, como por ejemplo:
Añade una vaca que come pasto. Añade un humano: la vaca alimenta al humano. Añade un extraterrestre que se come al humano. El humano también come vacas.
El enrutador determina qué agentes usar, en qué orden ejecutarlos y qué mensaje enviar a cada agente.
Opcionalmente, el enrutador se puede volver a ejecutar con comentarios de los usuarios sobre su plan generado, antes de ejecutar los agentes.
Luego, los agentes recomendados se ejecutan en orden, acumulando sus resultados en la pizarra compartida.
Finalmente, el marco combina las llamadas resultantes y las devuelve al cliente.
ENTRADA DEL USUARIO:
Add a sheep that eats grass
PRODUCCIÓN:
['mutation {n addCreature(input: {n creature_name: "sheep",n allowed_terrain: GRASSLAND,n age: 2,n icon_name: SHEEPn }) {n creature_namen allowed_terrainn agen icon_namen }n }']
['mutation {', ' addVegetation(input: {', ' vegetation_name: "Grass",', ' icon_name: GRASS,', ' allowed_terrain: LAND', ' }) {', ' vegetation_name', ' icon_name', ' allowed_terrain', ' }', '}']
['mutation {', ' addCreatureRelationship(input: {', ' from_name: "Sheep",', ' to_name: "Grass",', ' relationship_kind: EATS', ' }) {', ' id', ' }', '}']
Instalar Python 3.11 y poesía
Instalar dependencias.
poetry install
Para OpenAI:
export OPENAI_API_KEY="xxx"
Agregue eso a su script de inicialización de shell ( ~/.zprofile o similar)
Carga en terminal actual:
source ~/.zprofile
Guión de prueba:
./test.sh
Consulte el código fuente de ejemplo para obtener más detalles.
