llmemory 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84ebe29d1042b2efa07d02ded2a5374bbdcc1b0bad195a90d6cc5a15c1a2f73a
+  data.tar.gz: 6b6c0157acc13d89a07b9491c206a5a132d4c1e9c3c63a08f1810dd39681a067
+SHA512:
+  metadata.gz: cfd74b6f30e3d049de41596344a15c7b7734794a146a22e9dc2ad61153eb8fa584982efe1a4969bbe24fdbe2a079f46f8f42aeabd1e90e6f78f65d511fbc10df
+  data.tar.gz: 644dd2c11dbcdb40486d4a1b3cc33e5c13aa0ae0f9616358b4aff069d7b0ac7a04a263bb09a98657e58bcbefd11def65c7c5c711bbf6be3d36645512367439e3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 llmemory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,193 @@
+# llmemory
+
+Persistent memory system for LLM agents. Implements short-term checkpointing, long-term memory (file-based or **graph-based**), retrieval with time decay, and maintenance jobs.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "llmemory"
+```
+
+Then run `bundle install`.
+
+## Quick Start (Unified API)
+
+The recommended way to use llmemory in a chat is the unified `Llmemory::Memory` API. It abstracts short-term (conversation history) and long-term (extracted facts) and combines retrieval from both:
+
+```ruby
+# File-based long-term (default): facts and categories
+memory = Llmemory::Memory.new(user_id: "user_123", session_id: "conv_456")
+
+# Or graph-based long-term: entities and relations (knowledge graph + vector search)
+memory = Llmemory::Memory.new(user_id: "user_123", session_id: "conv_456", long_term_type: :graph_based)
+
+# Add user and assistant messages
+memory.add_message(role: :user, content: "Soy vegano y trabajo en OpenAI")
+memory.add_message(role: :assistant, content: "Entendido, lo recordaré")
+
+# Get full context for the next LLM call (recent conversation + relevant long-term memories)
+context = memory.retrieve("¿Qué preferencias tiene el usuario?", max_tokens: 2000)
+
+# Optionally consolidate current conversation into long-term (extract facts)
+memory.consolidate!
+
+# Clear session (short-term) while keeping long-term intact
+memory.clear_session!
+```
+
+- **`add_message(role:, content:)`** — Persists messages in short-term.
+- **`messages`** — Returns the current conversation history.
+- **`retrieve(query, max_tokens: nil)`** — Returns combined context: recent conversation + relevant long-term memories.
+- **`consolidate!`** — Extracts facts from the current conversation and stores them in long-term.
+- **`clear_session!`** — Clears short-term only.
+
+## Configuration
+
+```ruby
+Llmemory.configure do |config|
+  config.llm_provider = :openai
+  config.llm_api_key = ENV["OPENAI_API_KEY"]
+  config.llm_model = "gpt-4"
+  config.short_term_store = :memory  # or :redis, :postgres, :active_record
+  config.redis_url = ENV["REDIS_URL"]  # for :redis
+  config.long_term_type = :file_based  # or :graph_based (entities + relations)
+  config.long_term_store = :memory  # or :file, :postgres, :active_record
+  config.long_term_storage_path = "./llmemory_data"  # for :file
+  config.database_url = ENV["DATABASE_URL"]          # for :postgres
+  config.time_decay_half_life_days = 30
+  config.max_retrieval_tokens = 2000
+  config.prune_after_days = 90
+end
+```
+
+## Long-Term Storage
+
+Long-term memory can use different backends:
+
+| Store            | Class                       | Use case                          |
+|------------------|-----------------------------|-----------------------------------|
+| `:memory`        | `Storages::MemoryStorage`   | Default; in-memory, lost on exit  |
+| `:file`          | `Storages::FileStorage`     | Persist to disk (directory per user) |
+| `:postgres`      | `Storages::DatabaseStorage` | PostgreSQL (tables created automatically) |
+| `:active_record` | `Storages::ActiveRecordStorage` | Rails: usa ActiveRecord y tu DB existente |
+
+Set `config.long_term_store = :file`, `:postgres` or `:active_record` so that `Llmemory::Memory` and `FileBased::Memory` use it when no `storage:` is passed.
+
+**Long-term type:** use `long_term_type: :graph_based` in `Llmemory::Memory.new(...)` for entity/relation memory (knowledge graph + hybrid retrieval). See [Long-Term Memory (Graph-Based)](#long-term-memory-graph-based) below.
+
+**Rails (ActiveRecord):** añade `activerecord` a tu Gemfile si no está. Luego:
+
+```bash
+rails g llmemory:install
+rails db:migrate
+```
+
+La migración crea las tablas de long-term file-based (resources, items, categories), short-term (checkpoints) y, para graph-based, nodos, aristas y embeddings (`llmemory_nodes`, `llmemory_edges`, `llmemory_embeddings`). Para embeddings se usa pgvector; asegúrate de tener la extensión `vector` en PostgreSQL. Para usar ambas con ActiveRecord:
+
+```ruby
+# config/application.rb o config/initializers/llmemory.rb
+Llmemory.configure do |config|
+  config.short_term_store = :active_record   # historial de conversación en DB
+  config.long_term_store = :active_record    # hechos extraídos en DB
+  # ... llm, etc.
+end
+```
+
+Explicit storage:
+
+```ruby
+storage = Llmemory::LongTerm::FileBased::Storages.build(store: :file, base_path: "./data/llmemory")
+memory = Llmemory::LongTerm::FileBased::Memory.new(user_id: "u1", storage: storage)
+
+storage = Llmemory::LongTerm::FileBased::Storages.build(store: :postgres, database_url: ENV["DATABASE_URL"])
+memory = Llmemory::LongTerm::FileBased::Memory.new(user_id: "u1", storage: storage)
+
+# Rails
+storage = Llmemory::LongTerm::FileBased::Storages.build(store: :active_record)
+memory = Llmemory::LongTerm::FileBased::Memory.new(user_id: "u1", storage: storage)
+```
+
+## Long-Term Memory (Graph-Based)
+
+When you need **entities and relations** (e.g. “User works_at OpenAI”, “User prefers Ruby”) instead of flat facts and categories, use graph-based long-term memory. It combines:
+
+- **Knowledge graph** — Nodes (entities) and edges (subject–predicate–object relations).
+- **Vector store** — Embeddings (e.g. OpenAI `text-embedding-3-small`) for semantic search.
+- **Hybrid retrieval** — Vector search + graph traversal from matched nodes, then merged and ranked.
+- **Conflict resolution** — Exclusive predicates (e.g. `works_at`, `lives_in`) archive previous values when a new one is stored.
+
+### Unified API with graph-based
+
+```ruby
+memory = Llmemory::Memory.new(
+  user_id: "user_123",
+  session_id: "conv_456",
+  long_term_type: :graph_based
+)
+memory.add_message(role: :user, content: "Trabajo en Acme y vivo en Madrid")
+memory.consolidate!
+context = memory.retrieve("¿Dónde trabaja el usuario?")
+```
+
+### Lower-level graph-based API
+
+```ruby
+storage = Llmemory::LongTerm::GraphBased::Storages.build(store: :memory)  # or :active_record
+vector_store = Llmemory::VectorStore::MemoryStore.new(
+  embedding_provider: Llmemory::VectorStore::OpenAIEmbeddings.new
+)
+memory = Llmemory::LongTerm::GraphBased::Memory.new(
+  user_id: "user_123",
+  storage: storage,
+  vector_store: vector_store
+)
+memory.memorize("User works at Acme. User lives in Madrid.")
+context = memory.retrieve("where does user work", top_k: 10)
+candidates = memory.search_candidates("job", top_k: 20)
+```
+
+- **`memorize(conversation_text)`** — LLM extracts entities and relations (SPO triplets), upserts nodes/edges, resolves conflicts, and stores relation text in the vector store.
+- **`retrieve(query, top_k:)`** — Hybrid search: vector similarity + graph traversal; returns formatted context string.
+- **`search_candidates(query, user_id:, top_k:)`** — Used by `Retrieval::Engine`; returns `[{ text:, timestamp:, score: }]`.
+
+**Graph storage:** `:memory` (in-memory) or `:active_record` (Rails). For ActiveRecord, run `rails g llmemory:install` and migrate; the migration creates `llmemory_nodes`, `llmemory_edges`, and `llmemory_embeddings` (pgvector). Enable the `vector` extension in PostgreSQL for embeddings.
+
+## Lower-Level APIs
+
+### Short-Term Memory (Checkpointing)
+
+```ruby
+checkpoint = Llmemory::ShortTerm::Checkpoint.new(user_id: "user_123")
+checkpoint.save_state(conversation_state)
+state = checkpoint.restore_state
+```
+
+### Long-Term Memory (File-Based)
+
+```ruby
+memory = Llmemory::LongTerm::FileBased::Memory.new(user_id: "user_123")
+# or with explicit storage: storage: Llmemory::LongTerm::FileBased::Storages.build(store: :file)
+memory.memorize(conversation_text)
+context = memory.retrieve(query)
+```
+
+### Retrieval Engine
+
+```ruby
+retrieval = Llmemory::Retrieval::Engine.new(long_term_memory)
+context = retrieval.retrieve_for_inference(user_message, max_tokens: 2000)
+```
+
+### Maintenance
+
+```ruby
+Llmemory::Maintenance::Runner.run_nightly(user_id, storage: memory.storage)
+Llmemory::Maintenance::Runner.run_weekly(user_id, storage: memory.storage)
+Llmemory::Maintenance::Runner.run_monthly(user_id, storage: memory.storage)
+```
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/lib/generators/llmemory/install/install_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/generators/migration"
+
+module Llmemory
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Create migration for llmemory long-term storage (ActiveRecord)"
+
+      def self.next_migration_number(dirname)
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def copy_migration
+        migration_template "create_llmemory_tables.rb", "db/migrate/create_llmemory_tables.rb"
+      end
+    end
+  end
+end

data/lib/generators/llmemory/install/templates/create_llmemory_tables.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class CreateLlmemoryTables < ActiveRecord::Migration[7.0]
+  def change
+    create_table :llmemory_resources, id: false do |t|
+      t.string :id, null: false, primary_key: true
+      t.string :user_id, null: false
+      t.text :text, null: false
+      t.timestamps
+    end
+    add_index :llmemory_resources, :user_id
+
+    create_table :llmemory_items, id: false do |t|
+      t.string :id, null: false, primary_key: true
+      t.string :user_id, null: false
+      t.string :category, null: false
+      t.text :content, null: false
+      t.string :source_resource_id
+      t.timestamps
+    end
+    add_index :llmemory_items, :user_id
+
+    create_table :llmemory_categories do |t|
+      t.string :user_id, null: false
+      t.string :category_name, null: false
+      t.text :content, null: false
+      t.datetime :updated_at, null: false
+    end
+    add_index :llmemory_categories, [:user_id, :category_name], unique: true
+
+    create_table :llmemory_checkpoints do |t|
+      t.string :user_id, null: false
+      t.string :session_id, null: false
+      t.jsonb :state, null: false, default: {}
+      t.timestamps
+    end
+    add_index :llmemory_checkpoints, [:user_id, :session_id], unique: true
+
+    # Graph-based long-term memory (nodes = entities)
+    create_table :llmemory_nodes do |t|
+      t.string :user_id, null: false
+      t.string :entity_type, null: false
+      t.string :name, null: false
+      t.jsonb :properties, default: {}
+      t.timestamps
+    end
+    add_index :llmemory_nodes, [:user_id, :entity_type, :name], unique: true
+
+    # Graph-based long-term memory (edges = SPO relations)
+    create_table :llmemory_edges do |t|
+      t.string :user_id, null: false
+      t.references :subject, null: false, foreign_key: { to_table: :llmemory_nodes }
+      t.string :predicate, null: false
+      t.references :object, null: false, foreign_key: { to_table: :llmemory_nodes }
+      t.jsonb :properties, default: {}
+      t.datetime :archived_at
+      t.timestamps
+    end
+    add_index :llmemory_edges, [:user_id, :subject_id, :predicate]
+
+    # Vector store for hybrid retrieval (requires pgvector extension)
+    enable_extension "vector"
+    create_table :llmemory_embeddings do |t|
+      t.string :user_id, null: false
+      t.string :source_type, null: false
+      t.string :source_id, null: false
+      t.vector :embedding, limit: 1536
+      t.text :text_content
+      t.timestamps
+    end
+    add_index :llmemory_embeddings, [:user_id, :source_type, :source_id], unique: true
+  end
+end

data/lib/llmemory/configuration.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Llmemory
+  class Configuration
+    attr_accessor :llm_provider,
+                  :llm_api_key,
+                  :llm_model,
+                  :llm_base_url,
+                  :short_term_store,
+                  :redis_url,
+                  :long_term_type,
+                  :long_term_store,
+                  :long_term_storage_path,
+                  :database_url,
+                  :vector_store,
+                  :time_decay_half_life_days,
+                  :max_retrieval_tokens,
+                  :prune_after_days
+
+    def initialize
+      @llm_provider = :openai
+      @llm_api_key = ENV["OPENAI_API_KEY"]
+      @llm_model = "gpt-4"
+      @llm_base_url = nil
+      @short_term_store = :memory
+      @redis_url = ENV["REDIS_URL"] || "redis://localhost:6379/0"
+      @long_term_type = :file_based
+      @long_term_store = :memory
+      @long_term_storage_path = ENV["LLMEMORY_STORAGE_PATH"] || "./llmemory_data"
+      @database_url = ENV["DATABASE_URL"]
+      @vector_store = nil
+      @time_decay_half_life_days = 30
+      @max_retrieval_tokens = 2000
+      @prune_after_days = 90
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/llmemory/extractors/entity_relation_extractor.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Llmemory
+  module Extractors
+    class EntityRelationExtractor
+      def initialize(llm: nil)
+        @llm = llm || Llmemory::LLM.client
+      end
+
+      def extract(conversation_text)
+        prompt = <<~PROMPT
+          Extract entities and relations from this conversation as a knowledge graph.
+          - Entities: people, companies, places, preferences, concepts (type and name).
+          - Relations: subject-predicate-object triplets (e.g. User works_at OpenAI).
+          Use "User" as subject when the user talks about themselves.
+          Predicates: works_at, lives_in, prefers, is_allergic_to, likes, knows, current_job, current_city, etc.
+          Return ONLY valid JSON with this shape:
+          {"entities": [{"type": "person", "name": "User"}, {"type": "company", "name": "OpenAI"}], "relations": [{"subject": "User", "predicate": "works_at", "object": "OpenAI"}]}
+          Conversation:
+          #{conversation_text}
+        PROMPT
+        response = @llm.invoke(prompt.strip)
+        parse_response(response)
+      end
+
+      private
+
+      def parse_response(response)
+        json = extract_json(response)
+        return { entities: [], relations: [] } unless json.is_a?(Hash)
+        entities = Array(json["entities"] || json[:entities]).map { |e| normalize_entity(e) }
+        relations = Array(json["relations"] || json[:relations]).map { |r| normalize_relation(r) }
+        { entities: entities, relations: relations }
+      end
+
+      def extract_json(response)
+        response = response.to_s.strip
+        start_idx = response.index("{")
+        return nil unless start_idx
+        depth = 0
+        end_idx = nil
+        response.each_char.with_index(start_idx) do |c, i|
+          depth += 1 if c == "{"
+          depth -= 1 if c == "}"
+          if depth == 0
+            end_idx = i
+            break
+          end
+        end
+        return nil unless end_idx
+        JSON.parse(response[start_idx..end_idx])
+      rescue JSON::ParserError
+        nil
+      end
+
+      def normalize_entity(e)
+        {
+          type: (e["type"] || e[:type] || "concept").to_s.downcase,
+          name: (e["name"] || e[:name]).to_s.strip
+        }
+      end
+
+      def normalize_relation(r)
+        {
+          subject: (r["subject"] || r[:subject]).to_s.strip,
+          predicate: (r["predicate"] || r[:predicate]).to_s.strip.downcase.gsub(/\s+/, "_"),
+          object: (r["object"] || r[:object]).to_s.strip
+        }
+      end
+    end
+  end
+end

data/lib/llmemory/extractors/fact_extractor.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Llmemory
+  module Extractors
+    class FactExtractor
+      def initialize(llm: nil)
+        @llm = llm || Llmemory::LLM.client
+      end
+
+      def extract_items(conversation_text)
+        prompt = <<~PROMPT
+          Extract discrete facts from this conversation.
+          Focus on preferences, behaviors, and important details.
+          Conversation: #{conversation_text}
+          Return as JSON array of objects with "content" key. Example: [{"content": "User prefers Ruby"}, {"content": "User is vegan"}]
+        PROMPT
+        response = @llm.invoke(prompt.strip)
+        parse_items_response(response)
+      end
+
+      def evolve_summary(existing:, new_memories:)
+        memory_list_text = Array(new_memories).map { |m| "- #{m}" }.join("\n")
+        prompt = <<~PROMPT
+          You are a Memory Synchronization Specialist.
+          Topic Scope: User Profile
+
+          ## Original Profile
+          #{existing.to_s.empty? ? "No existing profile." : existing}
+
+          ## New Memory Items to Integrate
+          #{memory_list_text}
+
+          # Task
+          1. Update: If new items conflict with the Original Profile, overwrite the old facts.
+          2. Add: If items are new, append them logically.
+          3. Output: Return ONLY the updated markdown profile.
+        PROMPT
+        @llm.invoke(prompt.strip).to_s
+      end
+
+      def classify_item(content)
+        return "general" if content.to_s.strip.empty?
+        prompt = <<~PROMPT
+          Classify this fact into ONE category. Use lowercase with underscores. Examples: work_life, personal_life, preferences, general.
+          Fact: #{content}
+          Return ONLY the category name, nothing else.
+        PROMPT
+        result = @llm.invoke(prompt.strip).to_s.strip.downcase.gsub(/\s+/, "_")
+        result.empty? ? "general" : result
+      end
+
+      private
+
+      def parse_items_response(response)
+        json = extract_json_array(response)
+        return [] unless json
+        json.map { |item| item.is_a?(Hash) ? item : { "content" => item.to_s } }
+      end
+
+      def extract_json_array(response)
+        response = response.to_s.strip
+        start_idx = response.index("[")
+        return nil unless start_idx
+        end_idx = response.rindex("]")
+        return nil unless end_idx
+        JSON.parse(response[start_idx..end_idx])
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/llmemory/extractors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "extractors/fact_extractor"
+require_relative "extractors/entity_relation_extractor"
+
+module Llmemory
+  module Extractors
+  end
+end

data/lib/llmemory/llm/anthropic.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require_relative "base"
+
+module Llmemory
+  module LLM
+    class Anthropic < Base
+      DEFAULT_BASE_URL = "https://api.anthropic.com"
+
+      def initialize(api_key: nil, model: nil, base_url: nil)
+        @api_key = api_key || config.llm_api_key || ENV["ANTHROPIC_API_KEY"]
+        @model = model || config.llm_model || "claude-3-sonnet-20240229"
+        @base_url = base_url || config.llm_base_url || DEFAULT_BASE_URL
+      end
+
+      def invoke(prompt)
+        response = connection.post("v1/messages") do |req|
+          req.body = {
+            model: @model,
+            max_tokens: 1024,
+            messages: [{ role: "user", content: prompt }]
+          }.to_json
+          req.headers["Content-Type"] = "application/json"
+          req.headers["x-api-key"] = @api_key
+          req.headers["anthropic-version"] = "2023-06-01"
+        end
+
+        raise Llmemory::LLMError, "Anthropic API error: #{response.body}" unless response.success?
+
+        body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
+        content = body.dig("content", 0, "text")
+        content&.strip || ""
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: @base_url) do |f|
+          f.request :json
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/llm/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Llmemory
+  module LLM
+    class Base
+      def invoke(prompt)
+        raise NotImplementedError, "#{self.class}#invoke must be implemented"
+      end
+
+      protected
+
+      def config
+        Llmemory.configuration
+      end
+    end
+  end
+end

data/lib/llmemory/llm/openai.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require_relative "base"
+
+module Llmemory
+  module LLM
+    class OpenAI < Base
+      DEFAULT_BASE_URL = "https://api.openai.com/v1"
+
+      def initialize(api_key: nil, model: nil, base_url: nil)
+        @api_key = api_key || config.llm_api_key
+        @model = model || config.llm_model
+        @base_url = base_url || config.llm_base_url || DEFAULT_BASE_URL
+      end
+
+      def invoke(prompt)
+        response = connection.post("chat/completions") do |req|
+          req.body = {
+            model: @model,
+            messages: [{ role: "user", content: prompt }],
+            temperature: 0.3
+          }.to_json
+          req.headers["Content-Type"] = "application/json"
+          req.headers["Authorization"] = "Bearer #{@api_key}"
+        end
+
+        raise Llmemory::LLMError, "OpenAI API error: #{response.body}" unless response.success?
+
+        body = response.body.is_a?(Hash) ? response.body : JSON.parse(response.body.to_s)
+        body.dig("choices", 0, "message", "content")&.strip || ""
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: @base_url) do |f|
+          f.request :json
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/llmemory/llm.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "llm/base"
+require_relative "llm/openai"
+require_relative "llm/anthropic"
+
+module Llmemory
+  module LLM
+    def self.client
+      case Llmemory.configuration.llm_provider.to_sym
+      when :openai then OpenAI.new
+      when :anthropic then Anthropic.new
+      else
+        raise Llmemory::ConfigurationError, "Unknown LLM provider: #{Llmemory.configuration.llm_provider}"
+      end
+    end
+  end
+end