# Swarm_Ex
```elixir
Mix.install(
[
{:instructor, "~> 0.0.5"},
{:openai_ex, "~> 0.8.4"},
{:swarm_ex, git: "https://github.com/nrrso/swarm_ex.git", branch: "main"},
{:jason, "~> 1.4"}
],
config: [
instructor: [
adapter: Instructor.Adapters.OpenAI,
openai: [api_key: System.fetch_env!("LB_OPENAI_API_KEY")]
]
]
)
```
## Define Example Modules
```elixir
# Message Classification Tool
defmodule ClassifyMessageTool do
@behaviour SwarmEx.Tool
@impl true
def execute(%{message: message}) do
# TODO: Replace this with actual LLM call
# Placeholder for LLM classification
# Example API call structure:
# response = OpenAI.chat_completion(
# model: "gpt-3.5-turbo",
# messages: [
# %{role: "system", content: "You are a classifier that determines if messages are Star Wars related. Reply with true or false only."},
# %{role: "user", content: message}
# ]
# )
# For now, simple keyword matching
is_star_wars = String.downcase(message) |> String.contains?(["star wars", "jedi", "sith", "force"])
{:ok, %{is_star_wars: is_star_wars}}
end
@impl true
def validate(%{message: _}), do: :ok
def validate(_), do: {:error, :invalid_args}
@impl true
def cleanup(_), do: :ok
end
```
```elixir
# Star Wars Response Tool
defmodule StarWarsResponseTool do
@behaviour SwarmEx.Tool
@impl true
def execute(_args) do
{:ok, "May the Force be with you!"}
end
@impl true
def validate(_), do: :ok
@impl true
def cleanup(_), do: :ok
end
```
```elixir
defmodule TriageAgent do
use SwarmEx.Agent
@impl true
def init(opts) do
{:ok, opts}
end
@impl true
def terminate(_reason, _state), do: :ok
@impl true
def handle_message(message, state) when is_binary(message) do
# Directly execute the ClassifyMessageTool instead of using execute_tool
case ClassifyMessageTool.execute(%{message: message}) do
{:ok, %{is_star_wars: true}} ->
Logger.info("Message classified as Star Wars related. Handing off to StarWarsAgent.")
handoff_to_star_wars(message, state)
{:ok, %{is_star_wars: false}} ->
Logger.info("Message not Star Wars related. Providing general response.")
{:ok, "Hi, how can I help?", state}
{:error, reason} ->
Logger.error("Classification failed: #{inspect(reason)}")
{:error, "Sorry, I couldn't process your message."}
end
end
@impl true
def handle_tool(:respond, _args, state) do
{:ok, state}
end
defp handoff_to_star_wars(message, state) do
case state[:star_wars_agent] do
nil ->
{:error, "Star Wars agent not configured"}
agent_pid ->
case SwarmEx.send_message_to_pid(agent_pid, message) do
{:ok, response} -> {:ok, response, state}
error -> error
end
end
end
end
```
```elixir
# Star Wars Specialist Agent
defmodule StarWarsAgent do
use SwarmEx.Agent
@impl true
def init(opts) do
{:ok, opts}
end
@impl true
def terminate(_reason, _state), do: :ok
@impl true
def handle_message(message, state) do
case StarWarsResponseTool.execute(%{}) do
{:ok, response} -> {:ok, response, state}
{:error, reason} -> {:error, reason}
end
end
@impl true
def handle_tool(:respond, _args, state) do
{:ok, state}
end
end
```
## Instantiate Tools and Agents
```elixir
# Create network and agents
{:ok, network} = SwarmEx.create_network()
```
```elixir
# Register our tools
SwarmEx.register_tool(ClassifyMessageTool)
SwarmEx.register_tool(StarWarsResponseTool)
```
```elixir
# Create the Star Wars agent first
{:ok, star_wars_agent} = SwarmEx.create_agent(network, StarWarsAgent, name: "star_wars_agent")
```
```elixir
SwarmEx.Client.list_agents(network)
```
```elixir
# Create the triage agent with reference to the Star Wars agent
{:ok, triage_agent} = SwarmEx.create_agent(
network,
TriageAgent,
name: "triage_agent",
star_wars_agent: star_wars_agent
)
```
```elixir
SwarmEx.Client.list_agents(network)
```
## Sending Message
```elixir
# Test with non-Star Wars message
{:ok, regular_response} = SwarmEx.send_message(network, "triage_agent", "Hello, what's the weather like?")
IO.puts("Regular response: #{regular_response}")
```
```elixir
# Test with Star Wars message
{:ok, star_wars_response} = SwarmEx.send_message(network, "triage_agent", "Tell me about the Jedi")
IO.puts("Star Wars response: #{star_wars_response}")
```
