Upload groq.livemd

public-apps/groq.livemd

@@ -0,0 +1,480 @@
+<!-- livebook:{"app_settings":{"access_type":"public","show_source":true,"slug":"groq-agent"}} -->
+
+# Elixir groq
+
+```elixir
+Mix.install([
+  {:groq, "~> 0.1"},
+  {:hackney, "~> 1.18"},
+  {:jason, "~> 1.4"},
+  {:phoenix_live_view, "~> 0.18.3"},
+  {:kino, "~> 0.9.0"}
+])
+
+# Check if Jason is available
+json_library = if Code.ensure_loaded?(Jason), do: Jason, else: :error
+
+# Configure Groq to use the available JSON library
+Application.put_env(:groq, :json_library, json_library)
+
+System.put_env("GROQ_API_KEY", System.fetch_env!("LB_GROQ_API_KEY"))
+
+# Start the Groq application
+case Application.ensure_all_started(:groq) do
+  {:ok, _} -> IO.puts("Groq application started successfully")
+  {:error, error} -> IO.puts("Failed to start Groq application: #{inspect(error)}")
+end
+```
+
+## Using groq and tool call in liveview
+
+We are gonna use the client from https://github.com/connorjacobsen/groq-elixir/tree/main
+
+Basically is Groq's endpoint wrapper
+
+```elixir
+# Ensure all dependencies are started
+Application.ensure_all_started(:hackney)
+Application.ensure_all_started(:groq)
+```
+
+```elixir
+response = Groq.ChatCompletion.create(%{
+  "model" => "mixtral-8x7b-32768",
+  "messages" => [
+    %{
+      "role" => "user",
+      "content" => "Explain the importance of fast language models"
+    }
+  ]
+})
+
+case response do
+  {:ok, result} ->
+    IO.puts("Response content:")
+    case result do
+      %{"choices" => [%{"message" => %{"content" => content}} | _]} ->
+        IO.puts(content)
+      _ ->
+        IO.puts("Unexpected response structure: #{inspect(result)}")
+    end
+  {:error, error} ->
+    IO.puts("Error: #{inspect(error)}")
+end
+```
+
+### Create a custom function to use as a tool
+
+```elixir
+# Define a simple function to get the current time
+defmodule TimeFunctions do
+  def get_current_time do
+    {{year, month, day}, {hour, minute, second}} = :calendar.local_time()
+    "Current time: #{year}-#{month}-#{day} #{hour}:#{minute}:#{second}"
+  end
+end
+
+# Define the function's properties
+function_properties = [
+  %{
+    "name" => "get_current_time",
+    "description" => "Get the current time",
+    "parameters" => %{
+      "type" => "object",
+      "properties" => %{},
+      "required" => []
+    }
+  }
+]
+```
+
+### Let's call the function if the user need it
+
+```elixir
+# Create a chat completion request with function calling
+response = Groq.ChatCompletion.create(%{
+  "model" => "mixtral-8x7b-32768",
+  "messages" => [
+    %{
+      "role" => "user",
+      "content" => "What time is it?"
+    }
+  ],
+  "tools" => [
+    %{
+      "type" => "function",
+      "function" => Enum.at(function_properties, 0)
+    }
+  ],
+  "tool_choice" => "auto"
+})
+
+# Handle the response
+case response do
+  {:ok, result} ->
+    case result do
+      %{"choices" => [%{"message" => message} | _]} ->
+        case message do
+          %{"tool_calls" => [%{"function" => %{"name" => "get_current_time"}} | _]} ->
+            time = TimeFunctions.get_current_time()
+            IO.puts("Assistant requested the current time. #{time}")
+          _ ->
+            IO.puts("Assistant response: #{message["content"]}")
+        end
+      _ ->
+        IO.puts("Unexpected response structure: #{inspect(result)}")
+    end
+  {:error, error} ->
+    IO.puts("Error: #{inspect(error)}")
+end
+
+
+```
+
+### Let's build a Math Agent.
+
+Since the models can operate mathematical operations we are going to create an Ange to understand user query and if there any mathematical expresion we are going to use a 'calculate' function to process it.
+
+```elixir
+defmodule MathAgent do
+  def calculate(expression) do
+    try do
+      result = Code.eval_string(expression) |> elem(0)
+      Jason.encode!(%{result: result})
+    rescue
+      _ -> Jason.encode!(%{error: "Invalid expression"})
+    end
+  end
+
+  def function_properties do
+    [
+      %{
+        "type" => "function",
+        "function" => %{
+          "name" => "calculate",
+          "description" => "Evaluate a mathematical expression",
+          "parameters" => %{
+            "type" => "object",
+            "properties" => %{
+              "expression" => %{
+                "type" => "string",
+                "description" => "The mathematical expression to evaluate"
+              }
+            },
+            "required" => ["expression"]
+          }
+        }
+      }
+    ]
+  end
+
+  def create_chat_completion(messages) do
+    Groq.ChatCompletion.create(%{
+      "model" => "llama3-groq-70b-8192-tool-use-preview",
+      "messages" => messages,
+      "tools" => function_properties(),
+      "tool_choice" => "auto",
+      "max_tokens" => 4096
+    })
+  end
+
+  def handle_response({:ok, result}) do
+    case result do
+      %{"choices" => choices} when is_list(choices) and length(choices) > 0 ->
+        first_choice = Enum.at(choices, 0)
+        handle_message(first_choice["message"])
+      _ ->
+        {:error, "Unexpected response structure: #{inspect(result)}"}
+    end
+  end
+
+  def handle_response({:error, error}) do
+    {:error, "Error: #{inspect(error)}"}
+  end
+
+  defp handle_message(%{"tool_calls" => [tool_call | _]} = message) do
+    IO.puts("\nModel is using a tool:")
+    IO.inspect(message, label: "Full message")
+    
+    %{"function" => %{"name" => function_name, "arguments" => arguments}} = tool_call
+    case function_name do
+      "calculate" ->
+        args = Jason.decode!(arguments)
+        IO.puts("Calling calculate function with expression: #{args["expression"]}")
+        result = calculate(args["expression"])
+        IO.puts("Calculate function result: #{result}")
+        {:tool_call, tool_call["id"], function_name, result}
+      _ ->
+        {:error, "Unknown function: #{function_name}"}
+    end
+  end
+
+  defp handle_message(message) do
+    IO.puts("\nModel is not using a tool:")
+    IO.inspect(message, label: "Full message")
+    {:ok, message["content"]}
+  end
+
+  def run_conversation(user_prompt) do
+    IO.puts("Starting conversation with user prompt: #{user_prompt}")
+    
+    initial_messages = [
+      %{
+        "role" => "system",
+        "content" => "You are a calculator assistant. 
+        Use the calculate function to perform mathematical operations and provide the results. 
+        If the answer is not about Math, you will respond: Eee locoo, aguante Cristinaaaa 🇦🇷!"
+      },
+      %{
+        "role" => "user",
+        "content" => user_prompt
+      }
+    ]
+
+    case create_chat_completion(initial_messages) do
+      {:ok, result} ->
+        IO.puts("\nReceived initial response from Groq API")
+        case handle_response({:ok, result}) do
+          {:tool_call, id, name, content} ->
+            IO.puts("\nProcessing tool call result")
+            tool_message = %{
+              "tool_call_id" => id,
+              "role" => "tool",
+              "name" => name,
+              "content" => content
+            }
+            first_choice = Enum.at(result["choices"], 0)
+            new_messages = initial_messages ++ [first_choice["message"], tool_message]
+            IO.puts("\nSending follow-up request to Groq API")
+            case create_chat_completion(new_messages) do
+              {:ok, final_result} -> 
+                IO.puts("\nReceived final response from Groq API")
+                handle_response({:ok, final_result})
+              error -> error
+            end
+          other -> other
+        end
+      error -> error
+    end
+  end
+end
+```
+
+### Let's try with user input
+
+Trye
+
+```elixir
+user_input = "What is 25 * 4 + 10?"
+
+IO.puts("Running conversation with input: #{user_input}\n")
+case MathAgent.run_conversation(user_input) do
+  {:ok, response} -> IO.puts("\nFinal Response: #{response}")
+  {:error, error} -> IO.puts("\nError: #{error}")
+end
+```
+
+#### If we query some question that is not related about math we are going to receive according of what we have in our system prompt on how the model have to behave
+
+```elixir
+# Example of a query that might not use the tool
+user_input_no_tool = "What's the capital of France?"
+
+IO.puts("\n\nRunning conversation with input that might not use the tool: #{user_input_no_tool}\n")
+case MathAgent.run_conversation(user_input_no_tool) do
+  {:ok, response} -> IO.puts("\nFinal Response: #{response}")
+  {:error, error} -> IO.puts("\nError: #{error}")
+end
+```
+
+### Use Case: Retrieve information from "database" using natural lenguage as a query
+
+<!-- livebook:{"break_markdown":true} -->
+
+Let's create a fake 50.000 user database
+
+```elixir
+fake_database = Enum.map(1..50_000, fn _ ->
+  user_id = :crypto.strong_rand_bytes(16) |> Base.encode16(case: :lower)
+  minutes = :rand.uniform(1000)
+  {user_id, minutes}
+end)
+
+IO.puts("Sample of fake data (first 10 entries):")
+fake_database |> Enum.take(10) |> IO.inspect()
+
+defmodule DataStore do
+  def get_fake_database do
+    unquote(Macro.escape(fake_database))
+  end
+end
+
+IO.puts("Fake database generated and stored in DataStore module.")
+```
+
+###### Le'ts create a GroqChat module and create a function as a tool with the properties and call the client.
+
+###### We are going to use Kino to create a funny interface :)
+
+```elixir
+defmodule GroqChat do
+  # Use the fake database from the DataStore module
+  @fake_database DataStore.get_fake_database()
+
+  def get_top_users(n) do
+    @fake_database
+    |> Enum.sort_by(fn {_, minutes} -> minutes end, :desc)
+    |> Enum.take(n)
+    |> Enum.map(fn {user_id, minutes} -> %{user_id: user_id, minutes: minutes} end)
+    |> Jason.encode!()
+  end
+
+  def function_properties do
+    [
+      %{
+        "type" => "function",
+        "function" => %{
+          "name" => "get_top_users",
+          "description" => "Get the top N users with the most system usage time",
+          "parameters" => %{
+            "type" => "object",
+            "properties" => %{
+              "n" => %{
+                "type" => "integer",
+                "description" => "Number of top users to retrieve"
+              }
+            },
+            "required" => ["n"]
+          }
+        }
+      }
+    ]
+  end
+
+  def create_chat_completion(messages) do
+    Groq.ChatCompletion.create(
+      %{
+        "model" => "llama3-groq-70b-8192-tool-use-preview",
+        "messages" => messages,
+        "tools" => function_properties(),
+        "tool_choice" => "auto",
+        "max_tokens" => 4096
+      },
+      recv_timeout: 30_000  # Increase timeout to 30 seconds
+    )
+  end
+
+  def handle_response({:ok, result}) do
+    case result do
+      %{"choices" => choices} when is_list(choices) and length(choices) > 0 ->
+        first_choice = Enum.at(choices, 0)
+        handle_message(first_choice["message"])
+      _ ->
+        {:error, "Unexpected response structure: #{inspect(result)}"}
+    end
+  end
+
+  def handle_response({:error, error}) do
+    {:error, "Error: #{inspect(error)}"}
+  end
+
+  defp handle_message(%{"tool_calls" => [tool_call | _]} = message) do
+    IO.puts("\nModel is using a tool:")
+    IO.inspect(message, label: "Full message")
+    
+    %{"function" => %{"name" => function_name, "arguments" => arguments}} = tool_call
+    case function_name do
+      "get_top_users" ->
+        args = Jason.decode!(arguments)
+        IO.puts("Calling get_top_users function with n: #{args["n"]}")
+        result = get_top_users(args["n"])
+        IO.puts("Get top users function result: #{result}")
+        {:tool_call, tool_call["id"], function_name, result}
+      _ ->
+        {:error, "Unknown function: #{function_name}"}
+    end
+  end
+
+  defp handle_message(message) do
+    IO.puts("\nModel is not using a tool:")
+    IO.inspect(message, label: "Full message")
+    {:ok, message["content"]}
+  end
+
+  def run_conversation(user_prompt) do
+    IO.puts("Starting conversation with user prompt: #{user_prompt}")
+    
+    initial_messages = [
+      %{
+        "role" => "system",
+        "content" => "You are an assistant capable of retrieving information about top system users. 
+        Use the get_top_users function to retrieve information about users in database with 
+        the most system usage time. If question is not about user or mintues info respond: Eyy guachoo, esto solo para database"
+      },
+      %{
+        "role" => "user",
+        "content" => user_prompt
+      }
+    ]
+
+    case create_chat_completion(initial_messages) do
+      {:ok, result} ->
+        IO.puts("\nReceived initial response from Groq API")
+        case handle_response({:ok, result}) do
+          {:tool_call, id, name, content} ->
+            IO.puts("\nProcessing tool call result")
+            tool_message = %{
+              "tool_call_id" => id,
+              "role" => "tool",
+              "name" => name,
+              "content" => content
+            }
+            first_choice = Enum.at(result["choices"], 0)
+            new_messages = initial_messages ++ [first_choice["message"], tool_message]
+            IO.puts("\nSending follow-up request to Groq API")
+            case create_chat_completion(new_messages) do
+              {:ok, final_result} -> 
+                IO.puts("\nReceived final response from Groq API")
+                handle_response({:ok, final_result})
+              error -> error
+            end
+          other -> other
+        end
+      error -> error
+    end
+  end
+end
+
+# Create an input form with a submit option
+form = Kino.Control.form(
+  [
+    query: Kino.Input.text("Enter your query. Example: list the 5 user with most used the system?")
+  ],
+  submit: "Send"
+)
+
+# Create a frame to display the response
+frame = Kino.Frame.new()
+
+# Set up the event stream for form submission
+Kino.Control.stream(form)
+|> Kino.listen(fn %{data: %{query: query}} ->
+  Kino.Frame.render(frame, Kino.Markdown.new("**Loading...**"))
+  
+  # Make the API call
+  case GroqChat.run_conversation(query) do
+    {:ok, response} ->
+      Kino.Frame.render(frame, Kino.Markdown.new("**Response:**\n\n#{response}"))
+    {:error, error} ->
+      Kino.Frame.render(frame, Kino.Markdown.new("**Error:**\n\n#{error}"))
+  end
+end)
+
+# Render the UI elements
+Kino.Layout.grid([
+  form,
+  frame
+])
+```
+
+<!-- livebook:{"offset":13926,"stamp":{"token":"XCP.uif9L-BcwPrb46PT8dWaX-PK1L_knFhTLHIWcWPSMch2yDch8FA8yfOYF8Se-7uQ0JK-TJ0aFK7cW-wXCB9Y_hnMp5M3nT0n1HXBTRz3HNLcOqbTUN30","version":2}} -->