SwarmGo

The HierarchicalWorkflow uses a tree-like structure where tasks flow from top to bottom through multiple levels of specialized agents. This is ideal for sequential processing pipelines, clear reporting structures, and decomposing complex tasks into smaller, specialized roles.

workflow := swarmgo.NewWorkflow(apiKey, llm.OpenAI, swarmgo.HierarchicalWorkflow)

// Add agents to teams
workflow.AddAgentToTeam(managerAgent, swarmgo.SupervisorTeam)
workflow.AddAgentToTeam(researchAgent, swarmgo.ResearchTeam)
workflow.AddAgentToTeam(analysisAgent, swarmgo.AnalysisTeam)

// Connect agents in hierarchy
workflow.ConnectAgents(managerAgent.Name, researchAgent.Name)
workflow.ConnectAgents(researchAgent.Name, analysisAgent.Name)

An Agent is a core abstraction representing an AI assistant. It is defined by three primary fields:

• Name: A unique identifier (no spaces or special characters).
• Instructions: The system prompt that guides the agent's behavior.
• Model: The specific LLM model to use (e.g., gpt-4o).

Agents can also be extended with Functions (tools) and InstructionsFunc for dynamic prompting.

agent := &swarmgo.Agent{
	Name:         "Agent",
	Instructions: "You are a helpful assistant.",
	Model:        "gpt-4o",
}

Workflows in SwarmGo act as an orchestration layer to organize and coordinate multiple agents. They define communication paths, establish hierarchies, and manage how agents collaborate to accomplish complex tasks.

Workflows provide several key capabilities:

• Team Management: Organizing agents into functional teams.
• Leadership Roles: Designating specific agents as leaders for coordination.
• Flexible Routing: Enabling dynamic task routing between agents.
• Cycle Detection: Built-in mechanisms to detect and handle circular agent communications.
• State Management: Sharing state across different agents within the workflow.
• Error Handling: Robust recovery and error management during agent interactions.

The CollaborativeWorkflow is a peer-based pattern where agents work together as equals, passing tasks between one another. This pattern is best suited for parallel processing, iterative refinement, and dynamic task sharing within a team.

workflow := swarmgo.NewWorkflow(apiKey, llm.OpenAI, swarmgo.CollaborativeWorkflow)

// Add agents to document team
workflow.AddAgentToTeam(editor, swarmgo.DocumentTeam)
workflow.AddAgentToTeam(reviewer, swarmgo.DocumentTeam)
workflow.AddAgentToTeam(writer, swarmgo.DocumentTeam)

// Connect agents in collaborative pattern
workflow.ConnectAgents(editor.Name, reviewer.Name)
workflow.ConnectAgents(reviewer.Name, writer.Name)
workflow.ConnectAgents(writer.Name, editor.Name)

SwarmGo provides a memory system for storing and retrieving information. It supports automatic management of conversations and tool calls, as well as explicit memory storage with importance scoring and type categorization.

// Explicitly store a memory
memory := swarmgo.Memory{
    Content:    "User prefers dark mode",
    Type:       "preference",
    Context:    map[string]interface{}{"setting": "ui"},
    Timestamp:  time.Now(),
    Importance: 0.8,
}
agent.Memory.AddMemory(memory)

// Retrieve memories
recentMemories := agent.Memory.GetRecentMemories(5)
preferences := agent.Memory.SearchMemories("preference", nil)

This example demonstrates how to initialize a Swarm client using OpenAI, create a basic agent, and run a single conversation turn.

package main

import (
	"context"
	"fmt"
	"log"

	swarmgo "github.com/prathyushnallamothu/swarmgo"
	openai "github.com/sashabaranov/go-openai"
	llm "github.com/prathyushnallamothu/swarmgo/llm"
)

func main() {
	client := swarmgo.NewSwarm("YOUR_OPENAI_API_KEY", llm.OpenAI)

	agent := &swarmgo.Agent{
		Name:         "Agent",
		Instructions: "You are a helpful assistant.",
		Model:        "gpt-3.5-turbo",
	}

	messages := []openai.ChatCompletionMessage{
		{Role: "user", Content: "Hello!"},
	}

	ctx := context.Background()
	response, err := client.Run(ctx, agent, messages, nil, "", false, false, 5, true)
	if err != nil {
		log.Fatalf("Error: %v", err)
	}

	fmt.Println(response.Messages[len(response.Messages)-1].Content)
}

To use SwarmGo in your Go project, install the package using go get:

go get github.com/prathyushnallamothu/swarmgo

The StreamHandler is the primary way to consume the output of a StreamingResponse. Because StreamingResponse manages the loop of receiving tokens and handling tool calls, the handler acts as a callback mechanism.

When an agent decides to use a tool:

1. StreamingResponse accumulates the tool arguments.
2. Once the JSON arguments are complete, the function is executed.
3. OnToolCall is triggered with the completed llm.ToolCall.
4. A new stream is created to process the LLM's response to the tool's output.

This ensures that your UI or consumer can show text as it arrives and react immediately when a tool is invoked.