Release v0.2.0: Refactor Store to use AgentForge.Store GenServer implementation

Author: madawei2699

CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2025-03-30
+
+### Changed
+- **BREAKING**: Refactored LLMAgent.Store to leverage AgentForge.Store's GenServer implementation
+- Store interface now returns :ok instead of updated state maps
+- Store now uses process names (atoms) instead of directly returning state maps
+- Removed unused sequence_flows function and its helper functions from flows.ex
+
+### Fixed
+- Fixed warnings in the investment_portfolio.exs example
+- Fixed unused function parameters
+- Updated example code to use the correct Store interface
+
+### Documentation
+- Updated documentation to reflect Store interface changes
+- Enhanced dynamic workflow documentation to better showcase complex scenarios
+
 ## [0.1.1] - 2025-03-29
 
 ### Added

README.md

@@ -25,7 +25,7 @@ Add `llm_agent` to your list of dependencies in `mix.exs`:
 ```elixir
 def deps do
   [
-    {:llm_agent, "~> 0.1.1"},
+    {:llm_agent, "~> 0.2.0"},
     # Optional LLM provider dependencies
     {:openai, "~> 0.5.0"}, # If using OpenAI
     {:anthropic, "~> 0.1.0"} # If using Anthropic

guides/architecture.md

@@ -33,7 +33,7 @@ graph TD
 
 1. **Signals**: Represent events in the agent lifecycle
 2. **Handlers**: Process signals and update state
-3. **Store**: Manages conversation state and history
+3. **Store**: Manages conversation state and history using GenServer processes, providing a centralized state management system that leverages Elixir's OTP capabilities
 4. **Flows**: Combine handlers into coherent sequences
 5. **Providers**: Interface with LLM backends
 6. **Tools**: External capabilities the agent can use
@@ -76,11 +76,16 @@ classDiagram
     }
     
     class LLMAgent.Store {
-        +new(initial_state)
-        +add_message(state, role, content)
-        +add_thought(state, content)
-        +add_tool_call(state, name, args, result)
-        +prune_thoughts(state, max_thoughts)
+        +start_link(options)
+        +new(initial_state, options)
+        +add_message(store_name, role, content)
+        +add_thought(store_name, content)
+        +add_tool_call(store_name, name, args, result)
+        +get_llm_history(store_name)
+        +get_thoughts(store_name)
+        +get(store_name, key)
+        +put(store_name, key, value)
+        +delete(store_name, key)
     }
     
     class LLMAgent.Flows {

guides/dynamic_workflows.md

@@ -105,28 +105,35 @@ Below is a simplified implementation of this dynamic workflow:
 
 ```elixir
 defmodule InvestmentDemo do
-  # Process a user message and update state
-  def process_message(state, message) do
+  # Start a new conversation store
+  def start_conversation do
+    store_name = __MODULE__.Store
+    LLMAgent.Store.start_link(name: store_name)
+    store_name
+  end
+
+  # Process a user message using store
+  def process_message(store_name, message) do
     # Simulate LLM analyzing message and deciding which tool to use
-    {tool_name, tool_args, thinking} = simulate_llm_tool_selection(message, state)
+    {tool_name, tool_args, thinking} = simulate_llm_tool_selection(message, store_name)
 
     # Show the simulated thinking process
     IO.puts("Assistant thinking: #{thinking}")
 
     # Execute the selected tool if applicable
     if tool_name do
       # Execute the tool
-      tool_result = execute_tool(tool_name, tool_args, state)
+      tool_result = execute_tool(tool_name, tool_args, store_name)
 
-      # Update state with tool results
-      updated_state = update_state_with_tool_result(state, tool_name, tool_result)
+      # Update store with tool results
+      update_store_with_tool_result(store_name, tool_name, tool_result)
 
       # Process the result (may trigger another tool or generate response)
-      process_tool_result(updated_state, tool_name, tool_result)
+      process_tool_result(store_name, tool_name, tool_result)
     else
       # No tool selected, generate direct response
-      generate_final_response(state, message)
-      state
+      generate_final_response(store_name, message)
+      :ok
     end
   end
 

guides/getting_started.md

@@ -39,14 +39,20 @@ config :llm_agent, :anthropic,
 Creating a basic question-answering agent requires only a few lines of code:
 
 ```elixir
+# Create a store for our conversation
+store_name = MyApp.ConversationStore
+LLMAgent.Store.start_link(name: store_name)
+
 # Create a simple Q&A agent with a system prompt
 {flow, state} = LLMAgent.Flows.conversation(
-  "You are a helpful assistant that answers questions concisely."
+  "You are a helpful assistant that answers questions concisely.",
+  [],
+  store_name: store_name
 )
 
 # Process a user message
 message = "What is Elixir?"
-{:ok, result, new_state} = AgentForge.process(flow, state, LLMAgent.Signals.user_message(message))
+{:ok, result, new_state} = LLMAgent.process(flow, state, message)
 
 # Extract the assistant response
 response = result.data
@@ -78,15 +84,20 @@ tools = [
   }
 ]
 
+# Create a store for our conversation
+store_name = MyApp.ToolsConversationStore
+LLMAgent.Store.start_link(name: store_name)
+
 # Create an agent with tools
 {flow, state} = LLMAgent.Flows.conversation(
   "You are a helpful assistant that can perform calculations and tell the time.",
-  tools
+  tools,
+  store_name: store_name
 )
 
 # Process a message that might require a tool
 message = "What's 22 + 20?"
-{:ok, result, new_state} = AgentForge.process(flow, state, LLMAgent.Signals.user_message(message))
+{:ok, result, new_state} = LLMAgent.process(flow, state, message)
 ```
 
 ## Next Steps

lib/llm_agent/flows.ex

@@ -450,29 +450,29 @@ defmodule LLMAgent.Flows do
 
   # Create a flow that combines flows together in sequence
   # This function is currently unused but kept for future use
-  defp sequence_flows(flows) do
-    fn signal, state ->
-      Enum.reduce_while(flows, {signal, state}, &process_flow_result/2)
-    end
-  end
-
-  # Helper function to process flow results and determine continuation
-  defp process_flow_result(flow, {current_signal, current_state}) do
-    case flow.(current_signal, current_state) do
-      {:emit, new_signal, new_state} ->
-        {:cont, {new_signal, new_state}}
-
-      {:skip, new_state} ->
-        {:cont, {current_signal, new_state}}
-
-      {:halt, result, new_state} ->
-        {:halt, {:halt, result, new_state}}
-
-      {:error, reason, new_state} ->
-        {:halt, {:error, reason, new_state}}
-
-      other ->
-        {:halt, other}
-    end
-  end
+  # defp sequence_flows(flows) do
+  #   fn signal, state ->
+  #     Enum.reduce_while(flows, {signal, state}, &process_flow_result/2)
+  #   end
+  # end
+
+  # # Helper function to process flow results and determine continuation
+  # defp process_flow_result(flow, {current_signal, current_state}) do
+  #   case flow.(current_signal, current_state) do
+  #     {:emit, new_signal, new_state} ->
+  #       {:cont, {new_signal, new_state}}
+
+  #     {:skip, new_state} ->
+  #       {:cont, {current_signal, new_state}}
+
+  #     {:halt, result, new_state} ->
+  #       {:halt, {:halt, result, new_state}}
+
+  #     {:error, reason, new_state} ->
+  #       {:halt, {:error, reason, new_state}}
+
+  #     other ->
+  #       {:halt, other}
+  #   end
+  # end
 end

mix.exs

@@ -2,7 +2,7 @@ defmodule LLMAgent.MixProject do
   use Mix.Project
 
   @source_url "https://github.com/i365dev/llm_agent"
-  @version "0.1.1"
+  @version "0.2.0"
 
   def project do
     [