@brainlid
I asked Chat-GPT to make the code conversion to pure Phoenix Channels code (no dependency on LiveView) and here is the result, there seems to be more work to do since I get Jason encoder errors related to MessageDelta{} (protocol not implemented).
defmodule LangChainDemoWeb.AgentChatChannel do
use Phoenix.Channel
alias LangChainDemoWeb.AgentChatLive.Agent.ChatMessage
alias LangChain.Chains.LLMChain
alias LangChain.Message
alias LangChainDemo.FitnessUsers
alias LangChainDemo.FitnessLogs
alias LangChain.Message.ToolCall
alias LangChain.Message.ToolResult
# When a user joins the channel, initialize state
def join("agent_chat:lobby", _message, socket) do
current_user = FitnessUsers.get_fitness_user!(1)
llm_chain = initialize_llm_chain(current_user)
socket =
assign(socket, :current_user, current_user)
|> assign(:llm_chain, llm_chain)
|> assign(:display_messages, [
%ChatMessage{
role: :assistant,
hidden: false,
content: "Hello! I'm your personal trainer. How can I help you today?"
}
])
{:ok, socket}
end
# Handle incoming "validate" event
def handle_in("validate", %{"chat_message" => params}, socket) do
changeset = ChatMessage.create_changeset(params) |> Map.put(:action, :validate)
push(socket, "validate_response", %{form: to_form(changeset)})
{:noreply, socket}
end
# Handle incoming "save" event
def handle_in("save", %{"chat_message" => params}, socket) do
case ChatMessage.new(params) do
{:ok, message} ->
updated_socket = add_user_message(socket, message.content)
push(updated_socket, "message_saved", %{content: message.content})
{:noreply, run_chain(updated_socket)}
{:error, changeset} ->
push(socket, "save_error", %{errors: changeset.errors})
{:noreply, socket}
end
end
# Handle timezone event to update user's timezone
def handle_in("browser-timezone", %{"timezone" => timezone}, socket) do
user = socket.assigns.current_user
socket =
if timezone != user.timezone do
{:ok, updated_user} = FitnessUsers.update_fitness_user(user, %{timezone: timezone})
assign(socket, :current_user, updated_user)
else
socket
end
{:noreply, socket}
end
# Handle incoming chat delta from async processing
def handle_info({:chat_delta, delta}, socket) do
updated_chain = LLMChain.apply_delta(socket.assigns.llm_chain, delta)
push(socket, "chat_delta", %{delta: delta})
{:noreply, assign(socket, :llm_chain, updated_chain)}
end
# Handle tool execution message from async processing
def handle_info({:tool_executed, tool_message}, socket) do
message = %ChatMessage{role: tool_message.role, tool_results: tool_message.tool_results}
updated_socket = assign(socket, :llm_chain, LLMChain.add_message(socket.assigns.llm_chain, tool_message))
push(updated_socket, "tool_executed", %{tool_message: message})
{:noreply, updated_socket}
end
# Handle updated user information
def handle_info({:updated_current_user, updated_user}, socket) do
socket =
assign(socket, :current_user, updated_user)
|> assign(:llm_chain, LLMChain.update_custom_context(socket.assigns.llm_chain, %{current_user: updated_user}))
{:noreply, socket}
end
# Handle task errors in async processing
def handle_info({:task_error, reason}, socket) do
push(socket, "task_error", %{reason: reason})
{:noreply, socket}
end
# Function to initialize LLMChain
defp initialize_llm_chain(current_user) do
LLMChain.new!(%{
llm: ChatOpenAI.new!(%{model: "gpt-4", temperature: 0, request_timeout: 60_000, stream: true}),
custom_context: %{live_view_pid: self(), current_user: current_user},
verbose: false
})
end
# Handle running the LLM chain async
defp run_chain(socket) do
chain = socket.assigns.llm_chain
live_view_pid = self()
callback_fn = fn
%LangChain.MessageDelta{} = delta -> send(live_view_pid, {:chat_delta, delta})
%LangChain.Message{role: :tool} = message -> send(live_view_pid, {:tool_executed, message})
_ -> :ok
end
Task.start(fn ->
case LLMChain.run(chain, while_needs_response: true, callback_fn: callback_fn) do
{:ok, _updated_chain, _last_message} -> :ok
{:error, reason} -> send(live_view_pid, {:task_error, reason})
end
end)
assign(socket, :llm_chain, chain)
end
# Add user message to chain
defp add_user_message(socket, user_text) do
updated_chain = LLMChain.add_message(socket.assigns.llm_chain, Message.new_user!(user_text))
assign(socket, :llm_chain, updated_chain)
end
end
This library makes it much easier to integrate your Elixir application with one or more LLMs. It’s an adapter, shielding your app from swapping out which LLM you want to target for that next feature.
I’m looking for full time, US-based employment with or without AI!
