# Configure multiple bots

In this way we will explore different ways to configure multiple bots in the same application.

In this guide, the elixir application is called `my_bot` and the bot's modules will be `MyBot.Bot1`, `MyBot.Bot2`, ...

## Manually

The simpler and easiest way to start different bots, is to setup in a specific configuration value the bot's configuration:

``` elixir
config :my_bot,
  bots: [
    bot_name_1: [method: :polling, token: "TOKEN_BOT_1"],
    bot_name_2: [method: :polling, token: "TOKEN_BOT_2"]
  ]
```

NOTE: I recommend using the same name here than the one you use in your bots when doing `use ExGram.Bot, name: :bot_name_1`

And now in your `application.ex`, manually configure the childs:

``` elixir
  def start(_type, _args) do
    bots = Application.get_env(:my_bot, :bots)

    bot_config_1 = bots[:bot_name_1]
    bot_config_2 = bots[:bot_name_2]

    children = [
      ExGram,
      {MyBot.Bot1, bot_config_1},
      {MyBot.Bot2, bot_config_2}
    ]

    opts = [strategy: :one_for_one, name: MyBot.Supervisor]
    Supervisor.start_link(children, opts)
  end
```

## With a Dynamic Supervisor

If you plan to have many bots, that you maybe want to be able to start/stop as you want, or to add/delete new bots easily, using a DynamicSupervisor will help you with it.

We can keep the same configuration style, just change it to have the bot's module:

``` elixir
config :my_bot,
  bots: [
    bot_name_1: [bot: MyBot.Bot1, method: :polling, token: "TOKEN_BOT_1"],
    bot_name_2: [bot: MyBot.Bot2, method: :polling, token: "TOKEN_BOT_2"]
  ]
```

Now we will create a bot's dynamic supervisor:

- `lib/my_bot/bot_supervisor.ex`

``` elixir
defmodule MyBot.BotSupervisor do
  use DynamicSupervisor

  @spec start_link(any()) :: Supervisor.on_start() | :ignore
  def start_link(_init_arg) do
    DynamicSupervisor.start_link(__MODULE__, [], name: __MODULE__)
  end

  @impl true
  def init(_init_arg) do
    DynamicSupervisor.init(strategy: :one_for_one)
  end

  def start_bots() do
    bots = Application.get_env(:my_bot, :bots)

    bots
    |> Enum.with_index()
    |> Enum.map(fn {{bot_name, bot}, index} ->
      %{
        id: index,
        token: Keyword.fetch!(bot, :token),
        method: Keyword.fetch!(bot, :method),
        bot_name: bot_name,
        extra_info: Keyword.get(bot, :extra_info, %{}),
        bot: Keyword.fetch!(bot, :bot)
      }
    end)
    |> Enum.each(&start_bot/1)
  end

  def start_bot(bot) do
    name = String.to_atom("bot_#{bot.bot_name}_#{bot.id}")

    bot_options = [
      token: bot.token,
      method: bot.method,
      name: name,
      id: name,
      bot_name: bot.bot_name,
      extra_info: bot.extra_info
    ]

    child_spec = {bot[:bot], bot_options}

    {:ok, _} = DynamicSupervisor.start_child(__MODULE__, child_spec)
  end
end
```


> #### Note {: .info }
> NOTE: This sets the bot's name explicit (`bot_name: bot.bot_name`), this is done in order to allow to use the same bot module with different tokens.
> But it also implies that the name in the configuration is the one that will be used, and not the one setup in `use ExGram.Bot, name: <name>`, it only matters if you make direct calls to ExGram like `ExGram.send_message/3` with `bot: :bot_name`, if you don't need to release different bots with the same bot's module, I recommend deleting that line.

## Using `context.name` for Direct API Calls

When running multiple bots, it's crucial to understand how to identify which bot received an update. This is especially important when using the low-level API directly instead of the DSL.

### The DSL Handles This Automatically

The ExGram DSL (functions like `answer`, `edit`, `delete`) automatically uses `context.name` to identify the correct bot:

```elixir
def handle({:command, "start", _}, context) do
  # This automatically uses the correct bot
  answer(context, "Hello!")
end
```

No additional configuration needed - the DSL knows which bot to use!

### Manual API Calls Require `bot:` Option

When making direct ExGram method calls (outside the DSL), you **must** explicitly specify which bot to use. The `context.name` field contains the bot's name:

```elixir
def handle({:command, "notify_admin", _}, context) do
  admin_chat_id = get_admin_id()
  user = extract_user(context)

  # CORRECT: Use context.name to identify the bot
  ExGram.send_message(
    admin_chat_id,
    "User #{user.id} triggered notify_admin",
    bot: context.name  # This is crucial!
  )

  answer(context, "Admin has been notified")
end
```

> #### Pro tip {: .tip}
> Never hardcode the bot's name (`@name`) or use `MyBot.name()`, always use the `context.name` and pass it 
> around if you need it, like that you will always do API calls with the correct bot

### Why This Matters

Without specifying `bot: context.name`, ExGram will use the default token from config, which might be the wrong bot:

```elixir
# ❌ WRONG: May use wrong bot's token
ExGram.send_message(admin_chat_id, "Message")

# ✅ CORRECT: Uses the bot that received the update
ExGram.send_message(admin_chat_id, "Message", bot: context.name)
```

### Example: Background Task with Multiple Bots

If you need to send messages from a background task or GenServer, store the bot name and use it:

```elixir
defmodule MyApp.NotificationWorker do
  use GenServer

  def start_link(bot_name) do
    GenServer.start_link(__MODULE__, bot_name, name: __MODULE__)
  end

  def init(bot_name) do
    {:ok, %{bot_name: bot_name}}
  end

  def handle_info(:send_notification, state) do
    # Use the stored bot name
    ExGram.send_message(
      chat_id,
      "Scheduled notification",
      bot: state.bot_name
    )

    {:noreply, state}
  end
end
```

### Summary

- **DSL functions** (`answer`, `edit`, etc.) → Automatically use `context.name`
- **Direct API calls** (`ExGram.send_message`, etc.) → Must specify `bot: context.name`
- **Background tasks** → Store and reuse the bot name

See the [Low-Level API](low-level-api.md) guide for more information on direct API calls.


And finally, we just need to change our `application.ex` to start the supervisor and the bots:

- `lib/my_bot/application.ex`
``` elixir
  @impl true
  def start(_type, _args) do
    children = [
      ExGram,
      MyBot.BotSupervisor,
      {Task, &MyBot.BotSupervisor.start_bots/0},
      # ...
    ]

    opts = [strategy: :one_for_one, name: MyBot.Supervisor]
    Supervisor.start_link(children, opts)
  end
```