CBRkit

https://github.com/wi2trier/cbrkit
Admin
CBRkit is a customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI,...
Tokens:8,870
Snippets:121
Trust Score:7
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install CBRKit via pip

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Standard installation command for the library.

```shell
pip install cbrkit
```

--------------------------------

### Install CBRKit with optional dependencies

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Command to install the library with specific extra features.

```shell
pip install cbrkit[EXTRA_NAME,...]
```

--------------------------------

### Access CLI and API Help

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use these commands to view help documentation for the CBRkit command-line interface and REST API server.

```shell
cbrkit --help
```

```shell
cbrkit serve --help
```

--------------------------------

### Initialize sqlite_vec storage

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Configure a file-based sqlite_vec store with hybrid search capabilities.

```python
store = cbrkit.indexable.sqlite_vec[str, str](
    url="sqlite+aiosqlite:///cases.db",
    value_column="body", vector_dim=384, index_type="hybrid", conversion_func=embed,
)
store.put_index(frozendict(casebase))
retriever = cbrkit.retrieval.indexable.sqlite_vec(storage=store, search_type="hybrid")
```

--------------------------------

### Build and apply a basic synthesizer

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Standard workflow for synthesizing a retrieval result when the casebase fits within the LLM context window.

```python
import cbrkit

casebase = cbrkit.loaders.LOADER(...)
retriever = cbrkit.retrieval.build(...)
retrieval = cbrkit.retrieval.apply_query(...)
provider = cbrkit.synthesis.providers.PROVIDER(...)
prompt = cbrkit.synthesis.prompts.default(instructions)
synthesizer = cbrkit.synthesis.build(provider, prompt)
response = cbrkit.synthesis.apply_result(retrieval, synthesizer).response
```

--------------------------------

### Configure CBRkit Logging

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Place this in your project's __init__.py to enable and customize logging output levels for specific CBRkit modules.

```python
import logging

logging.basicConfig(
    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
    level=logging.INFO,
    datefmt="%Y-%m-%d %H:%M:%S",
)

logging.getLogger("cbrkit.sim.XXX").setLevel(logging.DEBUG) # to see debug messages from function XXX of the sim module
logging.getLogger("cbrkit.retrieval").setLevel(logging.DEBUG) # to see debug messages from the retrieval module
```

--------------------------------

### Initialize storage-backed retriever index

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

For storage-backed retrievers, index the storage object directly before wrapping it for retrieval.

```python
storage = cbrkit.indexable.lancedb(uri="./cases", table_name="cases")
storage.put_index(frozendict(casebase))
retriever = cbrkit.retrieval.indexable.lancedb(storage=storage, search_type="dense")
```

--------------------------------

### Configure typed storage backends

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Define schema using plain strings or typed models for pgvector storage.

```python
# plain strings — cbrkit builds the table
store = cbrkit.indexable.pgvector[str, str](
    url=..., value_column="body", pgvector_dim=384, conversion_func=embed,
)

# typed rows — a SQLAlchemy mapped class defines the schema
class Car(Base):
    __tablename__ = "cars"
    key: Mapped[str] = mapped_column(primary_key=True)
    desc: Mapped[str] = mapped_column()
    _pgvec: Mapped[Any] = mapped_column(cbrkit.indexable.PGVECTOR(384), nullable=False)

store = cbrkit.indexable.pgvector[str, Car](url=..., model=Car, value_column="desc", ...)
```

--------------------------------

### Build a Reuse Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Constructs a reuse pipeline by defining adaptation and similarity functions.

```python
reuser = cbrkit.reuse.build(
    adaptation_func=cbrkit.adapt.attribute_value(...),
    similarity_func=cbrkit.sim.attribute_value(...),
)
```

--------------------------------

### Load cases from directories or paths

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Load multiple files using glob patterns or use the unified path function to auto-detect file or directory inputs.

```python
# Load all files matching a glob pattern from a directory
casebase = cbrkit.loaders.directory("path/to/cases/", pattern="*.json")

# Unified path function: auto-detects whether path is a file or directory
casebase = cbrkit.loaders.path("path/to/cases.json")  # single file
casebase = cbrkit.loaders.path("path/to/cases/")      # directory
```

--------------------------------

### Load cases from SQLite

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Execute a SQL query to load cases directly from a SQLite database file.

```python
casebase = cbrkit.loaders.sqlite("path/to/database.db", "SELECT * FROM cases")
```

--------------------------------

### Build a Retrieval Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Construct a retriever using a similarity function. This serves as the base for executing retrieval queries.

```python
retriever = cbrkit.retrieval.build(
    cbrkit.sim.attribute_value(...)
)
```

--------------------------------

### Initialize self-contained retriever index

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use put_index on self-contained retrievers like bm25 to pre-index the casebase.

```python
from frozendict import frozendict

retriever = cbrkit.retrieval.indexable.bm25(conversion_func=cbrkit.sim.embed.bm25(language="en"))
retriever.put_index(frozendict(casebase))
```

--------------------------------

### Apply Sequential Retrieval Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Execute multiple retrievers sequentially by passing them as a collection to the apply_query function.

```python
result = cbrkit.retrieval.apply_query(casebase, query, (retriever1, retriever2))
```

--------------------------------

### Nest similarity functions

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Demonstrates creating complex, nested similarity measures for object-oriented case structures.

```python
cbrkit.sim.attribute_value(
    attributes={
        "manufacturer": cbrkit.sim.attribute_value(
            attributes={
                "name": cbrkit.sim.strings.spacy(model="en_core_web_lg"),
                "country": cbrkit.sim.strings.levenshtein(),
            },
            aggregator=cbrkit.sim.aggregator(pooling="mean"),
        ),
        "color": color_similarity # custom measure
        ...
    },
    aggregator=cbrkit.sim.aggregator(pooling="mean"),
)
```

--------------------------------

### Load cases from a file

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use the file loader to import cases from supported formats like JSON, TOML, YAML, XML, or CSV.

```python
import cbrkit
casebase = cbrkit.loaders.file("path/to/cases.[json,toml,yaml,xml,csv]")
```

--------------------------------

### Process large casebases with chunking

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Handle large datasets by processing synthesis in batches and aggregating partial results with a pooling prompt.

```python
import cbrkit

casebase = cbrkit.loaders.file(...)

queries = [...]
retriever = cbrkit.retrieval.dropout(...)
# run retrieval on each casebase chunk
retrievals = [cbrkit.retrieval.apply_query(casebase, query, retriever) for query in queries]

# batches are tuples of casebase, query, and retrieval similarities
batches = [(casebase, query, retrieval.similarities) for query, retrieval in zip(queries, retrievals)]

# Prompt which should be evaluated on each batch
prompt = cbrkit.synthesis.prompts.default(instructions="...")
provider = cbrkit.synthesis.providers.PROVIDER(...)
synthesizer = cbrkit.synthesis.build(provider, prompt)

# prompt to aggregate the partial results into a final result
pooling_prompt = cbrkit.synthesis.prompts.pooling(instructions="...")
pooling_func = cbrkit.synthesis.pooling(provider, pooling_prompt)
get_result = cbrkit.synthesis.chunks(synthesizer, pooling_func, size=10)
response = get_result(batches)
```

--------------------------------

### Create Sequential Retrievers

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Define multiple retriever instances, such as pre-filters, to be used in a sequential pipeline.

```python
retriever1 = cbrkit.retrieval.dropout(..., min_similarity=0.5, limit=20)
retriever2 = cbrkit.retrieval.dropout(..., limit=10)
```

--------------------------------

### Implement Async Re-ranking

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Chains a re-ranker after a first-stage retriever in an async pipeline.

```python
reranker = cbrkit.retrieval.rerank.cross_encoder(model="cross-encoder/ms-marco-MiniLM-L6-v2")

# Async first stage (e.g. pgvector) -> reranker
result = await cbrkit.retrieval.apply_query_indexed_async(query, [retriever, reranker])
```

--------------------------------

### Composing Multiple Phase Functions

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Execute multiple retrieval phases sequentially by passing a tuple of functions.

```python
result = cbrkit.retrieval.apply_query(casebase, query, (cheap_retriever, expensive_retriever))
```

--------------------------------

### Configure Taxonomy-Based Similarity

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Load a taxonomy from a YAML file to calculate hierarchical similarity.

```python
# Load taxonomy from file
taxonomy_sim = cbrkit.sim.taxonomy.build(
    path="taxonomy.yaml",
    measure=cbrkit.sim.taxonomy.wu_palmer(),
)
```

--------------------------------

### Generate metric list for cutoffs

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Automatically generate a list of metrics for specified cutoff points.

```python
metrics = cbrkit.eval.generate_metrics(["precision", "recall", "f1"], ks=[1, 5, 10])
```

--------------------------------

### Load cases from Polars data frames

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Integrate existing Polars data frames into the CBRKit workflow.

```python
import polars as pl
import cbrkit

df = pl.read_csv("path/to/cases.csv")
casebase = cbrkit.loaders.polars(df)
```

--------------------------------

### Using frozendict for Immutable Casebases

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Ensure casebase immutability to support specific components like indexed retrieval.

```python
from frozendict import frozendict
casebase = frozendict(cbrkit.loaders.file("cases.json"))
```

--------------------------------

### Load query collections

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Load multiple queries from files or Polars dataframes using standard loaders.

```python
 # for polars
queries = cbrkit.loaders.polars(pl.read_csv("path/to/queries.csv"))
# for any other supported file format
queries = cbrkit.loaders.file("path/to/queries.[json,toml,yaml,xml,csv]")
```

--------------------------------

### Build a Retain Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Constructs a retainer using an assessment function and a storage function to manage casebase updates.

```python
retainer = cbrkit.retain.build(
    assess_func=cbrkit.sim.generic.equality(),
    storage_func=cbrkit.retain.static(
        key_func=lambda keys: max(keys, default=-1) + 1,
        casebase=casebase,
    ),
)
```

--------------------------------

### Apply Utility Functions for Similarity

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Combine, cache, or transpose existing similarity functions.

```python
# Combining multiple similarity functions
combined_sim = cbrkit.sim.combine(
    sim_funcs=[sim1, sim2, sim3],
    aggregator=cbrkit.sim.aggregator(pooling="mean")
)

# Caching similarity results
cached_sim = cbrkit.sim.cache(base_sim_func)

# Transposing similarity functions
transposed_sim = cbrkit.sim.transpose(
    sim_func=number_sim,
    to_x=lambda s: float(s),
    to_y=lambda s: float(s)
)
```

--------------------------------

### Apply Retrieval Query

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Execute a built retriever against a casebase and query to obtain similarity scores and ranked cases.

```python
result = cbrkit.retrieval.apply_query(casebase, query, retriever)
```

--------------------------------

### Apply Reuse Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Applies a constructed reuser to retrieval results to adapt cases.

```python
result = cbrkit.reuse.apply_result(retrieval_result, reuser)
```

--------------------------------

### Compose CBR System

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Initializes a high-level System object to manage and reuse CBR phase configurations.

```python
system = cbrkit.system.System(
    casebase=casebase,
    retriever_factory=lambda config: retriever,
    reuser_factory=lambda config: reuser,
)

# Run individual phases
retrieval_result = system.retrieve(query)
reuse_result = system.reuse(query)

# Run the full cycle
cycle_result = system.cycle(query)
```

--------------------------------

### Define a Custom Retriever Module

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Create a Python module to define a retriever using cbrkit.retrieval.build, which can then be referenced by the CLI or API.

```python
import cbrkit

custom_retriever = cbrkit.retrieval.dropout(
    cbrkit.retrieval.build(
        cbrkit.sim.attribute_value(...),
    ),
    limit=10,
)
```

--------------------------------

### Combine Multiple Reuse Pipelines

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Executes multiple reuse pipelines by passing them as a collection to the apply function.

```python
reuser1 = cbrkit.reuse.build(...)
reuser2 = cbrkit.reuse.build(...)
result = cbrkit.reuse.apply_result(retrieval_result, (reuser1, reuser2))
```

--------------------------------

### Configure String Similarity Measures

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use these functions to compare string data using edit distance or exact matching.

```python
# Semantic similarity is covered by the `cbrkit.sim.embed` module.
# See below for details.

# Edit distance measures
levenshtein_sim = cbrkit.sim.strings.levenshtein()
jaro_sim = cbrkit.sim.strings.jaro()

# Exact matching
equality_sim = cbrkit.sim.generic.equality()
```

--------------------------------

### Export data using dumpers

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Export data to files, directories, or Markdown format using the cbrkit.dumpers module.

```python
import cbrkit

# Export to a file (format is inferred from the extension)
cbrkit.dumpers.file("output.json", data)
cbrkit.dumpers.file("output.yaml", data)

# Export to a directory (one file per entry)
cbrkit.dumpers.directory("output/", data)

# Or use the unified path function
cbrkit.dumpers.path("output.json", data)  # writes a single file
cbrkit.dumpers.path("output/", data)      # writes a directory

# Format data as a Markdown code block
md = cbrkit.dumpers.markdown()(data)
```

--------------------------------

### Compute evaluation metrics

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Pass custom metric functions to the compute function along with qrels and run data.

```python
results = cbrkit.eval.compute(
    qrels,
    run,
    metrics=["custom_metric@5"],
    metric_funcs={"custom_metric": custom_metric},
)
```

--------------------------------

### Bridge Sync and Async Re-ranking

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Wrappers to handle the boundary between synchronous retrievers and asynchronous re-rankers.

```python
retriever = cbrkit.retrieval.build(cbrkit.sim.attribute_value(...))
result = cbrkit.retrieval.apply_query(
    casebase, query, [retriever, cbrkit.retrieval.synced(reranker)]
)
```

```python
result = await cbrkit.retrieval.apply_query_async(
    casebase, query, [cbrkit.retrieval.threaded(retriever), reranker]
)
```

--------------------------------

### Configure Collection and Sequence Similarity

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Measure similarity for sets or sequences using Jaccard or A* mapping.

```python
# Jaccard similarity for sets (requires the `nltk` extra)
jaccard_sim = cbrkit.sim.collections.jaccard()

# Optimal sequence mapping using A* search
seq_sim = cbrkit.sim.collections.mapping(cbrkit.sim.generic.equality())
```

--------------------------------

### Enabling Multiprocessing

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Parallelize similarity computations within batches using the multiprocessing parameter.

```python
retriever = cbrkit.retrieval.build(sim_func, multiprocessing=True)
# or with a specific number of processes:
retriever = cbrkit.retrieval.build(sim_func, multiprocessing=4)
```

--------------------------------

### Configure attribute-value adaptation

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Define specific adaptation functions for individual attributes within a case using the global attribute_value adapter.

```python
cbrkit.adapt.attribute_value(
    attributes={
        "price": cbrkit.adapt.numbers.aggregate(),
        "color": cbrkit.adapt.strings.regex("CASE_PATTERN", "QUERY_PATTERN", "REPLACEMENT"),
        ...
    }
)
```

--------------------------------

### Query pre-indexed retriever

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Execute queries against a pre-indexed retriever using apply_query_indexed.

```python
result = cbrkit.retrieval.apply_query_indexed(query, retriever)
```

--------------------------------

### Filtering with dropout

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Apply limits and similarity thresholds to a retriever using the dropout wrapper.

```python
retriever = cbrkit.retrieval.dropout(
    cbrkit.retrieval.build(sim_func),
    limit=10,
    min_similarity=0.3,
)
```

--------------------------------

### Transpose cases for context reduction

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use a transpose prompt to shorten or filter case attributes before they are passed to the main synthesis prompt.

```python
from cbrkit.typing import JsonEntry

def encoder(value) -> dict:
    ...
baseprompt = cbrkit.synthesis.prompts.default(instructions, encoder=encoder)
# transform the entries, e.g., by shortening, leaving out irrelevant attributes, etc.
# In this case, the value of every field is truncated to 100 characters
def shorten(entry: dict) -> JsonEntry:
    entry = {k: str(v)[:100] for k, v in entry.items()}
    return cbrkit.dumpers.markdown()(entry)

prompt = cbrkit.synthesis.prompts.transpose(baseprompt, shorten)
synthesizer = cbrkit.synthesis.build(provider, prompt)
...
```

--------------------------------

### Parallelize Retrieval with Distribute

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Parallelizes retrieval across batches by wrapping a retriever in a distributed process.

```python
retriever = cbrkit.retrieval.distribute(
    cbrkit.retrieval.build(...),
    multiprocessing=True,  # or an integer for a specific number of processes
)
```

--------------------------------

### Define a single query

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Queries should match the type of the cases, typically defined as a dictionary.

```python
query = {"name": "John", "age": 25}
```

--------------------------------

### Build a Revise Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Constructs a revise pipeline using an assessment function and an optional repair function.

```python
reviser = cbrkit.revise.build(
    assess_func=cbrkit.sim.attribute_value(...),
    repair_func=some_adaptation_func,  # optional
)
```

--------------------------------

### Configure Embedding-Based Similarity

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Build similarity functions using SentenceTransformers or OpenAI embeddings, with optional caching.

```python
# Build a similarity function with embedding and scorer
embed_sim = cbrkit.sim.embed.build(
    conversion_func=cbrkit.sim.embed.sentence_transformers(
        model="all-MiniLM-L6-v2"
    ),
    sim_func=cbrkit.sim.embed.cosine()  # or dot(), angular(), euclidean(), manhattan()
)

# Using OpenAI embeddings
openai_sim = cbrkit.sim.embed.build(
    conversion_func=cbrkit.sim.embed.openai(
        model="text-embedding-3-small"
    ),
    sim_func=cbrkit.sim.embed.cosine()
)

# Caching embeddings for performance
cached_embed_func = cbrkit.sim.embed.cache(
    func=cbrkit.sim.embed.sentence_transformers(
        model="all-MiniLM-L6-v2"
    ),
    path="embeddings.sqlite3",
    table="strf/minilm"
)
cached_sim = cbrkit.sim.embed.build(
    conversion_func=cached_embed_func,
    sim_func=cbrkit.sim.embed.cosine()
)
```

--------------------------------

### Extract single query from collection

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use the singleton helper to extract a single query from a collection containing only one entry.

```python
query = cbrkit.helpers.singleton(queries)
```

--------------------------------

### Configure Number Similarity Measures

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Apply linear, exponential, or threshold-based similarity to numerical data.

```python
# Linear similarity with optional thresholds
linear_sim = cbrkit.sim.numbers.linear(max_distance=100)

# Exponential decay similarity
exp_sim = cbrkit.sim.numbers.exponential(alpha=0.1)

# Step functions
threshold_sim = cbrkit.sim.numbers.threshold(threshold=50)
```

--------------------------------

### cbrkit.sim.collections

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Functions for calculating similarity between collections and sequences.

```APIDOC
## cbrkit.sim.collections

### Description
Provides similarity measures for sets and sequences.

### Methods
- `cbrkit.sim.collections.jaccard()`: Returns a Jaccard similarity function for sets.
- `cbrkit.sim.collections.mapping(sim_func)`: Returns a sequence mapping similarity function using A* search.
```

--------------------------------

### cbrkit.sim.strings

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Functions for calculating similarity between string data.

```APIDOC
## cbrkit.sim.strings

### Description
Provides string similarity measures including edit distance and exact matching.

### Methods
- `cbrkit.sim.strings.levenshtein()`: Returns a Levenshtein edit distance similarity function.
- `cbrkit.sim.strings.jaro()`: Returns a Jaro similarity function.
- `cbrkit.sim.generic.equality()`: Returns an exact matching similarity function.
```

--------------------------------

### cbrkit.eval.compute

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Computes evaluation metrics for retrieval results based on ground truth relevance scores and retrieval similarity scores.

```APIDOC
## cbrkit.eval.compute

### Description
Computes a list of metrics for retrieval results by comparing ground truth relevance scores (qrels) against retrieval similarity scores (run).

### Parameters
- **qrels** (Mapping[str, Mapping[str, int]]) - Required - Ground truth relevance scores for query-case pairs.
- **run** (Mapping[str, Mapping[str, float]]) - Required - Retrieval similarity scores for query-case pairs.
- **metrics** (list) - Required - A list of metric names to compute (e.g., "precision@5").
- **metric_funcs** (dict) - Optional - A mapping of custom metric names to functions implementing the `cbrkit.typing.EvalMetricFunc` protocol.
```

--------------------------------

### Implement BM25 Retrieval

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Uses the BM25 retriever for sparse text-based retrieval. Requires the 'bm25' extra.

```python
bm25_func = cbrkit.sim.embed.bm25(language="en")
retriever = cbrkit.retrieval.dropout(
    cbrkit.retrieval.indexable.bm25(conversion_func=bm25_func),
    limit=10,
)
result = cbrkit.retrieval.apply_query(casebase, query, retriever)
```

--------------------------------

### Configure Graph Similarity

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Calculate graph similarity using algorithms like Graph Edit Distance with A* search.

```python
# Using Graph Edit Distance (GED) with A* search
graph_sim = cbrkit.sim.graphs.astar.build(
    node_sim_func=cbrkit.sim.generic.equality(),
    node_matcher=lambda n1, n2: n1 == n2,
    edge_matcher=lambda e1, e2: e1 == e2,
)
```

--------------------------------

### Initialize a built-in number aggregator

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Use the generator function to create a number adaptation function with a specified pooling strategy.

```python
# pooling can be a string like "mean", "min", "max", "sum", etc. or a custom PoolingFunction
number_adapter = cbrkit.adapt.numbers.aggregate(pooling="mean")
```

--------------------------------

### cbrkit.sim.embed

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Functions for embedding-based similarity calculations.

```APIDOC
## cbrkit.sim.embed

### Description
Provides tools to build similarity functions based on vector embeddings.

### Methods
- `cbrkit.sim.embed.build(conversion_func, sim_func)`: Constructs a similarity function using a specific embedding model and similarity metric.
- `cbrkit.sim.embed.cache(func, path, table)`: Wraps an embedding function with caching capabilities.
```

--------------------------------

### cbrkit.eval.generate_metrics

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Helper function to generate a list of metric strings for various cutoff points.

```APIDOC
## cbrkit.eval.generate_metrics

### Description
Automatically generates a list of metric strings formatted with cutoff points (e.g., 'precision@5') for a given set of base metrics and cutoff values.

### Parameters
- **metrics** (list) - Required - List of base metric names (e.g., ['precision', 'recall']).
- **ks** (list) - Required - List of integer cutoff points (e.g., [1, 5, 10]).
```

--------------------------------

### Define a custom pair adaptation function

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Define a function that takes a case and a query as arguments to perform custom adaptation logic.

```python
def replace_adapter(case: str, query: str) -> str:
    return query if case != query else case
```

--------------------------------

### cbrkit.sim.graphs

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Functions for calculating similarity between graph structures.

```APIDOC
## cbrkit.sim.graphs.astar.build

### Description
Constructs a graph similarity function using the A* search algorithm.

### Parameters
- `node_sim_func`: Similarity function for nodes.
- `node_matcher`: Function to match nodes.
- `edge_matcher`: Function to match edges.
```

--------------------------------

### Define a custom evaluation metric

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Implement the EvalMetricFunc protocol to create a custom metric function for retrieval evaluation.

```python
def custom_metric(
    qrels: Mapping[str, Mapping[str, int]],
    run: Mapping[str, Mapping[str, float]],
    k: int,
    relevance_level: int,
) -> float:
    # Custom metric logic here
    return 0.0
```

--------------------------------

### Execute Full CBR Cycle

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Orchestrates all four CBR phases in a single call using the cycle module.

```python
result = cbrkit.cycle.apply_query(
    casebase,
    query,
    retrievers=retriever,
    reusers=reuser,
    revisers=reviser,
    retainers=retainer,
)
# Access results from each phase
retrieval_result = result.retrieval
reuse_result = result.reuse
revise_result = result.revise
retain_result = result.retain
```

--------------------------------

### Combine Multiple Retrievers

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Merges results from multiple retrievers using an aggregator.

```python
retriever1 = cbrkit.retrieval.build(...)
retriever2 = cbrkit.retrieval.indexable.bm25(...)

combined = cbrkit.retrieval.combine(
    retriever_funcs=[retriever1, retriever2],
    aggregator=cbrkit.sim.aggregator(pooling="mean"),
)
result = cbrkit.retrieval.apply_query(casebase, query, combined)
```

--------------------------------

### Implement Embedding-Based Retrieval

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Performs vector similarity search using an embedding function with caching. Requires vector similarity search capabilities.

```python
embed_func = cbrkit.sim.embed.cache(
    func=cbrkit.sim.embed.sentence_transformers(model="all-MiniLM-L6-v2"),
    path="embeddings.sqlite3",
    table="strf/minilm",
)
retriever = cbrkit.retrieval.dropout(
    cbrkit.retrieval.indexable.embed(conversion_func=embed_func),
    limit=10,
)
result = cbrkit.retrieval.apply_query(casebase, query, retriever)
```

--------------------------------

### Define custom similarity measure

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Create a function that accepts parameters named x and y to compare a case and a query.

```python
def color_similarity(x: str, y: str) -> float:
    if x == y:
        return 1.0
    elif x in y or y in x:
        return 0.5

    return 0.0
```

--------------------------------

### cbrkit.sim.numbers

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Functions for calculating similarity between numerical data.

```APIDOC
## cbrkit.sim.numbers

### Description
Provides numerical similarity measures with configurable parameters.

### Methods
- `cbrkit.sim.numbers.linear(max_distance)`: Returns a linear similarity function.
- `cbrkit.sim.numbers.exponential(alpha)`: Returns an exponential decay similarity function.
- `cbrkit.sim.numbers.threshold(threshold)`: Returns a step-based threshold similarity function.
```

--------------------------------

### Apply Revise Pipeline

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Applies a constructed reviser to the results obtained from the reuse phase.

```python
result = cbrkit.revise.apply_result(reuse_result, reviser)
```

--------------------------------

### Validate casebase with Pydantic

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Ensure loaded cases conform to a specific schema using Pydantic models.

```python
from pydantic import BaseModel

class Car(BaseModel):
    price: int
    year: int
    model: str

casebase = cbrkit.loaders.validate(casebase, Car)
```

--------------------------------

### Define attribute-value similarity

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Configures a global similarity measure for attribute-value data, allowing for custom measure references.

```python
cbrkit.sim.attribute_value(
    attributes={
        "price": cbrkit.sim.numbers.linear(),
        "color": color_similarity # custom measure
        ...
    },
    aggregator=cbrkit.sim.aggregator(pooling="mean"),
)
```

--------------------------------

### Aggregate similarity scores

Source: https://github.com/wi2trier/cbrkit/blob/main/README.md

Uses the predefined aggregator to transform a list of similarity scores into a single global score.

```python
similarities = [0.8, 0.6, 0.9]
aggregator = cbrkit.sim.aggregator(pooling="mean")
global_similarity = aggregator(similarities)
```
Tokens:
Raw