Agentframeworks deel 3: Swarm

Inhoudsopgave

• Inhoudsopgave
• Inleiding
• Eerste indruk
• Belangrijkste concepten
• client.run()
• Agents
• Instructies
• Functies
• Code voorbeeld: een schaalbaar agent systeem met router
• Casus
• Structuur van het project
• De Router Agent
• Gespecialiseerde Agents
• Utility Functies
• Conclusie

Inleiding

Afgelopen vrijdag, net voor het weekend begon, publiceerde OpenAI een nieuw klein lichtgewicht framework online. OpenAI heeft sinds de release van o1 sowieso niet stil gezeten, want hoewel dat nog maar een maandje geleden was kwamen ze sindsdien onder meer met:

-De realtime api - waarmee je via websockets een soort streaming interactie kunt aangaan met hun modellen, wat met name voor voice handig is. 🔗

-Canvas - een soort Artifacts kopie. 🔗

-Advanced voice mode - de uitgebreide voice to voice service, helaas formeel nog niet in Europa, maar met een VPN wel al te gebruiken. (leuk fragmentje van de advanced voice mode bij Renze op Zondag 🔗)

..en dat terwijl ook het nieuws van de ene na de andere hooggeplaatste medewerker die het bedrijf verlaat ons om de oren vliegt.

Swarm is tussen de hierboven geplaatste nieuwsberichten waarschijnlijk minder groot nieuws, maar ik was wel blij verrast door de aankondiging. het geeft ons toch weer een extra optie om te overwegen bij het bouwen van multi-agentic applicaties.

Eerste indruk

OpenAI’s Swarm is geen afgerond product of een grote library waarin alle use cases zijn uitgewerkt. Het is super klein en super eenvoudig te begrijpen. De package wordt dan ook omschreven als “educatief” door de makers. Wat prettig is, is dat een agent in Swarm, niet gekoppeld is aan de Assistants api van OpenAI, in het geval van agents vindt alle logica heel transparant plaats bij de client. Met wat kleine aanpassingen is Swarm dan ook prima bruikbaar met andere modellen dan die van OpenAI.

Wat je als een nadeel zou kunnen ervaren is dat bepaalde services of utilities die andere frameworks wel hebben bij Swarm niet standaard aangeboden worden, denk aan een visuele representatie van workflows, of tracing van runs.

Belangrijkste concepten

client.run()

Kort samengevat doorloop je met een Swarm run() de volgende stappen:

Agents

Uiteraard is het definieren van een agent ook van cruciaal belang in een agent orchestration framework. In Swarm is een Agent niet perse gedefinieerd ans een antropomorfische entiteit. Eerder moet je denken aan een set van instructies, functies en instellingen. Door deze redelijk brede definitie zijn agents relatief flexibel en bruikbaar voor diverse doeleinden in Swarm.

Instructies

De instructies van een Agent vormen de basis voor het “gedrag” ervan. De instructies worden direct omgezet in de systeemprompt van een conversatie. Interessant is dat de instructies zowel een string als een functie kunnen zijn:

# Statische instructies
agent = Agent(
    instructions="Je bent een behulpzame agent."
)

# Dynamische instructies
def instructions(context_variables):
    user_name = context_variables["user_name"]
    return f"Help de gebruiker, {user_name}, met wat ze ook maar willen."

agent = Agent(
    instructions=instructions
)

Dit biedt flexibiliteit om de instructies dynamisch aan te passen op basis van context.

Functies

Functies in Swarm zijn letterlijk python functies, dus dat maakt het werken ermee vrij natuurlijk. Functies in Swarm worden direct uitgevoerd door de agent. Dit betekent dat wanneer een agent besluit een functie aan te roepen, deze onmiddellijk wordt uitgevoerd. Een interessante eigenschap is dat een functie een nieuwe Agent kan retourneren, waardoor de uitvoering wordt overgedragen aan deze nieuwe agent. Als een functie een context_variables parameter definieert, wordt deze automatisch gevuld met de context variabelen die zijn meegegeven aan client.run().

Code voorbeeld: een schaalbaar agent systeem met router

Casus

Om het geheel wat te verduidelijken heb ik een klein voorbeeld uitgewerkt in deze GitHub repository:

GitHub - jwa91/swarm_example

Contribute to jwa91/swarm_example development by creating an account on GitHub.

github.com

1. clone de repo en install als package met pip install -e .
2. swarm_example

De repo maakt gebruik van het Swarm framework om een schaalbaar multi-agent systeem te demonstreren. Via een 'Router Agent' worden gebruikersverzoeken geanalyseert om deze door te sturen naar gespecialiseerde agents. Deze aanpak illustreert hoe je met Swarm een flexibel en uitbreidbaar systeem kunt bouwen, waarbij je elke agent eenvoudig kunt aanpassen aan de specifieke taak waarvoor je de agent inricht (bijvoorbeeld een hogere temperature voor een agent die een “creatieve” taak heeft, een lage temperature voor een agent die helpt met progammeren).

Structuur van het project

Het project is georganiseerd in een heldere mapstructuur:

src/swarm_example/
├── agents/
│   ├── brainstormer/
│   ├── editor/
│   ├── programmer/
│   ├── router.py
│   └── utils.py
└── main.py

Elke gespecialiseerde agent (Brainstormer, Editor, Programmer) heeft zijn eigen directory met configuratiebestanden en instructies. Deze modulaire opzet maakt het eenvoudig om nieuwe agents toe te voegen of bestaande te wijzigen.

De Router Agent

Het startpunt is de Router Agent, gedefinieerd in router.py. Deze agent heeft als taak om gebruikersverzoeken te analyseren en te beslissen welke gespecialiseerde agent het beste geschikt is om te antwoorden. De Router Agent maakt gebruik van drie functies:

def transfer_to_brainstormer():
    return brainstormer_agent

def transfer_to_editor():
    return editor_agent

def transfer_to_programmer():
    return programmer_agent

Deze functies demonstreren hoe Swarm's flexibiliteit kan worden benut om de controle over te dragen aan een andere agent. De Router Agent roept simpelweg de juiste functie aan, die vervolgens de bijbehorende gespecialiseerde agent retourneert.

Gespecialiseerde Agents

Het systeem bevat drie gespecialiseerde agents:

1. Brainstormer Agent: Genereert creatieve ideeën over elk gegeven onderwerp. (goedkoop taalmodel, hoge temperatuur)
2. Editor Agent: Redigeert en verbetert tekst. (groot taalmodel, gemiddelde temperatuur)
3. Programmer Agent: Biedt programmeer-assistentie (groot taalmodel, lage temperatuur)

Voor het voorbeeld heb ik de laatste 2 agents ook wat specifieke functies gegeven, zoals het ophalen van instructies qua taalgebruik en codeer conventies.

Elke agent heeft zijn eigen configuratiebestand (*_configuration.json) waarin LLM-parameters kunnen worden aangepast, en een instructiebestand (instructions.md) dat het gedrag van de agent definieert.

Utility Functies

De utils.py file bevat enkele handige functies die door alle agents worden gebruikt:

• create_agent(): Een factory functie voor het aanmaken van agents.
• save_content(): Een functie om gegenereerde content op te slaan als markdown bestand.

Ik vond deze opzet een prettige manier om zowel flexibel als schaalbaar te kunnen zijn.

Conclusie

De Agentic frameworks en concepten vliegen op dit moment als paddestoelen uit de grond, en de N is nog te laag om het echt als een trend te zien, maar een voorzichtige eerste schifting valt al wel te maken. Met Ell en nu ook Swarm heb ik in deze blogserie eerst twee frameworks getest die met relatief weinig abstracties een vrij simpele makkelijk te begrijpen benadering bieden.

De volgende twee frameworks die op de lijst staan, LangGraph en LlamaIndex (en dan specifiek LlamaIndex Workflows), hebben wat minder doorzichtige patronen maar dan weer wel veel meer out of the box koppelingen en utilities.

Het grote en groeiende aanbod in verscheidenheid van dit soort frameworks toont in ieder geval wel aan dat het werken met agents heel veel mensen bezighoudt. Zoals altijd hoor ik het graag als je een reactie hebt op de blog zelf of op het werken met agents in het algemeen.

JW.