Switch to llm-access library

docs/architecture.md

@@ -24,14 +24,8 @@ The project follows a modular architecture with the following main components:
      - [`SummarizePreprocessor`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/preprocessor/SummarizePreprocessor.java): Uses LLMs to generate concise summaries of artifacts while preserving key information, with configurable templates for different artifact types.
      - [`SentencePreprocessor`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/preprocessor/SentencePreprocessor.java): Splits text documents into individual sentences while maintaining the original document as a parent element.
 3. **Embedding Creators** (`embeddingcreator` package)
-   - [`EmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/EmbeddingCreator.java): Base class for creating embeddings
-   - Implementations:
-     - [`OpenAiEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/OpenAiEmbeddingCreator.java): Uses OpenAI's embedding models to create vector representations of text, supporting various models like text-embedding-3-large.
-     - [`OllamaEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/OllamaEmbeddingCreator.java): Integrates with Ollama's local embedding models, providing an alternative to cloud-based solutions.
-     - [`OpenWebUiEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/OpenWebUiEmbeddingCreator.java): Integrates with Open WebUI servers for embedding generation, supporting local deployment with OpenAI-compatible APIs.
-     - [`OnnxEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/OnnxEmbeddingCreator.java): Uses ONNX models for local embedding generation, offering high performance and offline capabilities.
-     - [`MockEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/MockEmbeddingCreator.java): Provides zero vectors for testing purposes, useful for development and testing scenarios.
-     - All extend [`CachedEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/CachedEmbeddingCreator.java) for caching support, improving performance by storing and reusing embeddings.
+   - [`EmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/EmbeddingCreator.java): LiSSA-side adapter that maps LiSSA `Element`s and configuration to the framework-neutral embedding creators of the [`io.github.ardoco:llm-access`](https://github.com/ardoco/llm-access) library.
+   - The library provides the actual implementations (OpenAI, Ollama, ONNX, Open WebUI, and a mock), all with transparent caching and token-length handling. The `openai` creator uses OpenAI embedding models such as `text-embedding-3-large`; `ollama`/`openwebui` integrate with local/OpenAI-compatible endpoints; `onnx` runs models locally for offline use.
 4. **Element Stores** (`elementstore` package)
    - [`ElementStore`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/elementstore/ElementStore.java): Manages storage and retrieval of processed elements with their embeddings, supporting similarity-based search and hierarchical relationships.
    - **Retrieval Strategies** (`elementstore/strategy` package):

docs/caching.md

@@ -2,50 +2,21 @@
 
 ## Overview
 
-LiSSA implements a sophisticated caching system to improve performance and ensure reproducibility of results. The caching system consists of the following components:
-
-1. **Cache Interface** (`cache` package)
-   - [`Cache`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/Cache.java): Core generic interface defining cache operations, parameterized by cache key type
-   - [`CacheKey`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/CacheKey.java): Base interface for cache keys with JSON serialization support and local key generation
-   - [`CacheParameter`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/CacheParameter.java): Interface defining cache configuration and key creation logic
-   - **Specialized Cache Keys**:
-     - [`ClassifierCacheKey`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/classifier/ClassifierCacheKey.java): Cache key for classifier operations (model name, seed, temperature, mode, content)
-     - [`EmbeddingCacheKey`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/embedding/EmbeddingCacheKey.java): Cache key for embedding operations (model name, content)
-   - **Cache Parameters**:
-     - [`ClassifierCacheParameter`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/classifier/ClassifierCacheParameter.java): Configuration for classifier caches (model name, seed, temperature)
-     - [`EmbeddingCacheParameter`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/embedding/EmbeddingCacheParameter.java): Configuration for embedding caches (model name)
-2. **Cache Implementations**
-   - [`Hierarchical Cache`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/HierarchicalCache.java): Two cache levels with a synchronization mechanism
-     - Changes are applied to both levels
-     - Reads use a Conflict Resolution Strategy to ensure consistent results
-     - If a cache entry is missing in one level during a read, it is also written to the other level
-   - [`LocalCache`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/LocalCache.java): File-based cache implementation that stores data in JSON format
-     - Implements dirty tracking to optimize writes
-     - Automatically saves changes on shutdown
-     - Supports atomic writes using temporary files
-   - [`RedisCache`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/RedisCache.java): Redis-based cache implementation
-     - Uses Redis for high-performance caching
-     - Supports both string and object serialization
-   - [`RestRedisCache`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/RestRedisCache.java): REST-based Redis cache implementation
-     - Uses REST API to interact with Redis server
-     - Provides an alternative to direct Redis connections, useful for shared caches
-     - Configuration through environment variables, see [Usage Instructions](#usage-instructions)
-3. **Cache Management**
-   - [`CacheManager`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/cache/CacheManager.java): Central manager for cache instances
-     - Manages cache directory configuration
-     - Provides singleton access to cache instances
-     - Handles cache creation and retrieval based on origin and cache parameters
-     - Ensures cache uniqueness by validating parameters
-4. **Caching Usage**
-   The caching system is used in several key components:
-   - **Embedding Creators**: Caches vector embeddings to avoid recalculating them
-     - Uses `EmbeddingCacheParameter` to identify unique embedding configurations
-     - Cache keys are automatically generated based on content using the model name
-   - **Classifiers**: Caches LLM responses for classification tasks
-     - Uses `ClassifierCacheParameter` to identify unique classifier configurations
-     - Cache keys include model name, seed, temperature, and content
-   - **Preprocessors**: Caches preprocessing results for text summarization and other operations
-     - Uses `ClassifierCacheParameter` for LLM-based preprocessing
+LiSSA relies on the caching subsystem provided by the [`io.github.ardoco:llm-access`](https://github.com/ardoco/llm-access) library to improve performance and ensure reproducibility of results. That library owns the cache abstraction and its implementations, so LiSSA no longer ships its own copies:
+
+1. **Cache abstraction**: `Cache`, `CacheKey`, and `CacheParameter`, plus typed keys/parameters for chat (`ChatCacheKey` / `ChatCacheParameter`) and embedding (`EmbeddingCacheKey` / `EmbeddingCacheParameter`) operations.
+2. **Cache implementations**: a hierarchical (two-level) cache with a conflict-resolution strategy, a file-based `LocalCache` (JSON, atomic writes, dirty tracking), a `RedisCache`, and a REST-based `RestRedisCache`.
+3. **Cache management**: a `CacheManager` that configures the cache directory and provides cache instances keyed by origin and parameters.
+
+See the [llm-access documentation](https://github.com/ardoco/llm-access) for the cache internals. The rest of this page describes how LiSSA configures and uses the cache (the configuration and environment variables are unchanged).
+
+### Caching Usage
+
+The caching system is used in several key components:
+
+- **Embedding Creators**: cache vector embeddings to avoid recalculating them (keyed by `EmbeddingCacheParameter`: model name).
+- **Classifiers**: cache LLM responses for classification tasks (keyed by `ChatCacheParameter`: model name, seed, temperature, content).
+- **Preprocessors**: cache results of LLM-based preprocessing (keyed by `ChatCacheParameter`).
 
 ## Key Concepts
 
@@ -58,7 +29,7 @@ Cache keys uniquely identify cached items and consist of two parts:
 ### Cache Parameters
 
 Cache parameters define the configuration that makes a cache unique:
-- **ClassifierCacheParameter**: Model name, seed, and temperature for reproducible LLM results
+- **ChatCacheParameter**: Model name, seed, and temperature for reproducible LLM results
 - **EmbeddingCacheParameter**: Model name only (embeddings are deterministic)
 
 Parameters are used to:

docs/configuration.md

@@ -13,8 +13,7 @@ Configuration options in LiSSA are defined in the code through several mechanism
 1. **Component Classes**: Each component (e.g., `ArtifactProvider`, `Preprocessor`, `Classifier`) has a corresponding class that defines its configuration options. For example:
    - [`TextArtifactProvider`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/artifactprovider/TextArtifactProvider.java) defines options for text-based artifact loading
    - [`CodeTreePreprocessor`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/preprocessor/CodeTreePreprocessor.java) defines options for code tree processing
-   - [`OpenAiEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/OpenAiEmbeddingCreator.java) defines options for OpenAI embedding generation
-   - [`OpenWebUiEmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/OpenWebUiEmbeddingCreator.java) defines options for Open WebUI embedding generation
+   - the [`EmbeddingCreator`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/embeddingcreator/EmbeddingCreator.java) adapter maps the `embedding_creator` configuration (e.g. `openai`, `ollama`, `onnx`, `openwebui`, `mock`) to the embedding creators provided by the [`io.github.ardoco:llm-access`](https://github.com/ardoco/llm-access) library
 2. **Configuration Classes**: The [`Configuration`](../src/main/java/edu/kit/kastel/sdq/lissa/ratlr/configuration/Configuration.java) class serves as the central configuration container, defining the structure of the configuration file.
 3. **Example Configurations**: You can find example configurations in the `example-configs` directory, which demonstrate different configuration setups for various use cases.
 4. **Configuration Template**: The `config-template.json` file provides a template with all available configuration options and their default values.

example-configs/transitive/d2m.json

@@ -45,6 +45,7 @@
   "classifier" : {
     "name" : "reasoning_openai",
     "args" : {
+      "model" : "gpt-4o-mini"
     }
   },
   "result_aggregator" : {

example-configs/transitive/m2c.json

@@ -47,6 +47,7 @@
   "classifier" : {
     "name" : "reasoning_openai",
     "args" : {
+      "model" : "gpt-4o-mini"
     }
   },
   "result_aggregator" : {

pom.xml

@@ -52,11 +52,6 @@
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
     </dependency>
-    <dependency>
-      <groupId>com.knuddels</groupId>
-      <artifactId>jtokkit</artifactId>
-      <version>1.1.0</version>
-    </dependency>
     <dependency>
       <groupId>com.tngtech.archunit</groupId>
       <artifactId>archunit-junit5</artifactId>
@@ -88,6 +83,11 @@
       <artifactId>picocli</artifactId>
       <version>${picocli.version}</version>
     </dependency>
+    <dependency>
+      <groupId>io.github.ardoco</groupId>
+      <artifactId>llm-access</artifactId>
+      <version>0.1.0-SNAPSHOT</version>
+    </dependency>
     <dependency>
       <groupId>io.github.ardoco</groupId>
       <artifactId>metrics</artifactId>
@@ -109,22 +109,12 @@
       <artifactId>tree-sitter-java</artifactId>
       <version>0.23.5</version>
     </dependency>
-    <dependency>
-      <groupId>io.github.cdimascio</groupId>
-      <artifactId>dotenv-java</artifactId>
-      <version>3.2.0</version>
-    </dependency>
     <dependency>
       <groupId>io.soabase.record-builder</groupId>
       <artifactId>record-builder-processor</artifactId>
       <version>${record-builder.version}</version>
       <scope>provided</scope>
     </dependency>
-    <dependency>
-      <groupId>org.fuchss</groupId>
-      <artifactId>rest-redis</artifactId>
-      <version>0.1.4</version>
-    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-engine</artifactId>
@@ -155,11 +145,6 @@
       <artifactId>testcontainers-junit-jupiter</artifactId>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>redis.clients</groupId>
-      <artifactId>jedis</artifactId>
-      <version>7.5.2</version>
-    </dependency>
   </dependencies>
   <repositories>
     <repository>

src/main/java/edu/kit/kastel/sdq/lissa/cli/command/TransitiveTraceCommand.java

@@ -10,12 +10,12 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import edu.kit.kastel.mcse.ardoco.llm.util.KeyGenerator;
 import edu.kit.kastel.sdq.lissa.ratlr.Evaluation;
 import edu.kit.kastel.sdq.lissa.ratlr.Statistics;
 import edu.kit.kastel.sdq.lissa.ratlr.configuration.EvaluationConfiguration;
 import edu.kit.kastel.sdq.lissa.ratlr.configuration.GoldStandardConfiguration;
 import edu.kit.kastel.sdq.lissa.ratlr.knowledge.TraceLink;
-import edu.kit.kastel.sdq.lissa.ratlr.utils.KeyGenerator;
 
 import picocli.CommandLine;
 

src/main/java/edu/kit/kastel/sdq/lissa/ratlr/Evaluation.java

@@ -14,8 +14,8 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
+import edu.kit.kastel.mcse.ardoco.llm.cache.CacheManager;
 import edu.kit.kastel.sdq.lissa.ratlr.artifactprovider.ArtifactProvider;
-import edu.kit.kastel.sdq.lissa.ratlr.cache.CacheManager;
 import edu.kit.kastel.sdq.lissa.ratlr.classifier.Classifier;
 import edu.kit.kastel.sdq.lissa.ratlr.configuration.EvaluationConfiguration;
 import edu.kit.kastel.sdq.lissa.ratlr.configuration.EvaluationConfigurationBuilder;

src/main/java/edu/kit/kastel/sdq/lissa/ratlr/Main.java

@@ -9,8 +9,8 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
+import edu.kit.kastel.mcse.ardoco.llm.cache.CacheManager;
 import edu.kit.kastel.sdq.lissa.ratlr.artifactprovider.ArtifactProvider;
-import edu.kit.kastel.sdq.lissa.ratlr.cache.CacheManager;
 import edu.kit.kastel.sdq.lissa.ratlr.classifier.Classifier;
 import edu.kit.kastel.sdq.lissa.ratlr.configuration.EvaluationConfiguration;
 import edu.kit.kastel.sdq.lissa.ratlr.context.ContextStore;

src/main/java/edu/kit/kastel/sdq/lissa/ratlr/Optimization.java

@@ -14,7 +14,7 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-import edu.kit.kastel.sdq.lissa.ratlr.cache.CacheManager;
+import edu.kit.kastel.mcse.ardoco.llm.cache.CacheManager;
 import edu.kit.kastel.sdq.lissa.ratlr.configuration.OptimizerConfiguration;
 import edu.kit.kastel.sdq.lissa.ratlr.knowledge.TraceLink;
 import edu.kit.kastel.sdq.lissa.ratlr.promptoptimizer.PromptOptimizer;