That is done inside the schema files for the models you are trying to link. The context handles mostly controller logic like CRUD, which you will need to update to work with the new relation.

If you’re interested in a example, this is one of the better ones: Elixir learning: Making a unified tagging system with many to many ecto relations

One thing that doesn’t seem to get emphasized enough is that Phoenix Contexts are primarily about cleaning up the controller code and getting domain logic out of the controllers. Compare from

Programming Phoenix
https://media.pragprog.com/titles/phoenix/code/controllers_views_templates/listings/rumbl/web/controllers/user_controller.ex

defmodule Rumbl.UserController do
  use Rumbl.Web, :controller

  def index(conn, _params) do
    users = Repo.all(Rumbl.User) # accessing the Ecto repo directly
    render conn, "index.html", users: users
  end
end

to Programming Phoenix 1.4
https://media.pragprog.com/titles/phoenix14/code/controllers_views_templates/listings/rumbl/lib/rumbl_web/controllers/user_controller.ex

defmodule RumblWeb.UserController do
  use RumblWeb, :controller

  alias Rumbl.Accounts

  def index(conn, _params) do
    users = Accounts.list_users() # here it's up to the Accounts context to figure out where the data comes from
    render(conn, "index.html", users: users)
  end
end

From that perspective it’s OK to start with one context. Once domain logic starts piling up in your first context module you’ll probably have a much better idea how to break out additional contexts.

When it comes to Bounded Contexts you need a lot more domain information and understanding up front in order to make some good decisions. Ideally each bounded context would have data autonomy i.e. it’s own database (separate Ecto repo) so you wouldn’t be using Ecto joins any way.

programming-phoenix-1-4_b2_0 p.73:

Sometimes it may be tricky to determine if two resources belong to the same context or not. In those cases, prefer distinct contexts per resource and refactor later if necessary. Otherwise you can easily end-up with large contexts of loosely related entities. In other words: if you are unsure, you should prefer explicit modules (contexts) between resources.

but

Chris McCord warns about premature extraction - i.e. it’s all about tradeoffs

Also:

• Michał Muskała: Putting Contexts in Context
• Lessons From Using Phoenix 1.3