Kapso

https://docs.leeroo.com/docs
Admin
Kapso is an open-source AI factory and Python framework that autonomously builds software for...
Tokens:71,277
Snippets:892
Trust Score:7.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### DeployConfig Initialization Example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Example of initializing a DeployConfig instance and accessing its properties.

```python
from kapso.deployment import DeployConfig

config = DeployConfig(
    solution=solution,
    env_vars={
        "API_KEY": "xxx",
        "DEBUG": "true",
    },
    timeout=600,
    coding_agent="gemini",
)

print(config.code_path)  # "/path/to/solution"
print(config.goal)       # "Create a sentiment API"
```

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

### start()

Source: https://docs.leeroo.com/docs/deployment/api-reference

Starts or restarts a stopped deployment.

```APIDOC
## start()

### Description
Start or restart a stopped deployment.

### Signature
`def start(self) -> None`
```

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

### Start knowledge-graph infrastructure

Source: https://docs.leeroo.com/docs/installation

Run the provided script to start local Weaviate and Neo4j instances in Docker.

```bash
bash scripts/start_infra.sh
```

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

### Software.start() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates restarting a stopped deployment and running it again.

```python
# After stop()
deployed_program.stop()
print(deployed_program.is_healthy())  # False

# Restart
deployed_program.start()
print(deployed_program.is_healthy())  # True

# Can run again
result = deployed_program.run({"text": "hello again"})
```

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

### Software.start() method definition

Source: https://docs.leeroo.com/docs/deployment/api-reference

Defines the interface for starting or restarting a deployment.

```python
@abstractmethod
def start(self) -> None
```

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

### Software.logs() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates printing the logs returned by the deployment.

```python
print(deployed_program.logs())
# Initialized local deployment
# run() called with: {"text": "hello"}
# run() completed: status=success
```

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

### kapso learn grade command example

Source: https://docs.leeroo.com/docs/reference/cli

Example of grading a bank against a specific split manifest.

```bash
kapso learn grade --bank ./bank --bank-head lr_042 --split splits/d1.yaml
```

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

### kapso learn import command examples

Source: https://docs.leeroo.com/docs/reference/cli

Examples of importing archived campaign tarballs or subsets into the trajectory store.

```bash
kapso learn import --subset docs/plans/learning/d1-subset.yaml
kapso learn import --archive gs://bucket/runs/campaign/20260731T092629_lane-a2.tgz
```

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

### Software.name property usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates accessing the deployment strategy name.

```python
print(deployed_program.name)  # "modal"
```

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

### Install Kapso dependencies

Source: https://docs.leeroo.com/docs/benchmarks/ioai-2026

Install the package in editable mode to set up the environment.

```bash
pip install -e .
```

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

### kapso learn mine command example

Source: https://docs.leeroo.com/docs/reference/cli

Example of mining all un-mined imported trajectories.

```bash
kapso learn mine --all
```

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

### Software.run() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates how to execute a program and handle the resulting status.

```python
result = deployed_program.run({"text": "hello"})

if result["status"] == "success":
    print(result["output"])
else:
    print(f"Error: {result['error']}")
```

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

### Install MLE-Bench

Source: https://docs.leeroo.com/docs/installation

Clones the MLE-Bench repository, installs Git LFS, and installs required dependencies. Requires Git LFS to be installed.

```bash
git clone https://github.com/openai/mle-bench.git
cd mle-bench
git lfs install
git lfs fetch --all
git lfs pull
pip install -e .
cd ..

pip install -r benchmarks/mle/requirements.txt
```

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

### Install the package from source

Source: https://docs.leeroo.com/docs/installation

Clone the repository and set up a dedicated Conda environment for development.

```bash
git clone https://github.com/leeroo-ai/kapso.git
cd kapso
conda create -n kapso_conda python=3.12
conda activate kapso_conda
pip install -e .
```

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

### Install RelBench

Source: https://docs.leeroo.com/docs/installation

Installs the RelBench package from PyPI.

```bash
pip install relbench
```

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

### Deploying solutions with kapso deploy

Source: https://docs.leeroo.com/docs/reference/cli

Examples of deploying a solution directory using various flags like strategy, environment variables, and interactive mode.

```bash
kapso deploy --solution-path ./solution
kapso deploy --solution-path ./solution --strategy docker
kapso deploy --solution-path ./solution --env API_KEY=xxx --interactive
```

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

### Install Leeroo Kapso

Source: https://docs.leeroo.com/docs/knowledge/learning-pipeline

Command to install the Leeroo Kapso framework via pip.

```bash
pip install leeroo-kapso
```

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

### Install and log in to the coding-agent CLIs

Source: https://docs.leeroo.com/docs/installation

Install the OpenAI and Anthropic CLIs and perform interactive browser-based authentication.

```bash
npm install -g @openai/codex
codex login

npm install -g @anthropic-ai/claude-code
claude auth login
```

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

### kapso evolve command usage examples

Source: https://docs.leeroo.com/docs/reference/cli

Examples of running the kapso evolve command with different configurations, including goal strings, goal files, iteration limits, evaluation directories, and resume functionality.

```bash
kapso evolve --goal "Build a web scraper for news articles"
kapso evolve --goal-file problem.txt --iterations 20
kapso evolve --goal "Build a classifier" --eval-dir ./eval/ --data-dir ./data/
kapso evolve --goal "Build a classifier" --output ./campaign --resume
```

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

### Install ALE-Bench

Source: https://docs.leeroo.com/docs/installation

Clones the ALE-Bench repository and installs dependencies. Requires Docker and libcairo2-dev.

```bash
git clone https://github.com/SakanaAI/ALE-Bench.git
cd ALE-Bench
pip install .
pip install ".[eval]"
bash ./scripts/docker_build_202301.sh $(id -u) $(id -g)
cd ..
```

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

### Install and login to OpenAI Codex

Source: https://docs.leeroo.com/docs/evolve/coding-agents

Commands to install the OpenAI Codex CLI and authenticate the session.

```bash
npm install -g @openai/codex
codex login
```

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

### Initialize Kapso evolve()

Source: https://docs.leeroo.com/docs/evolve/execution-flow

The entry point for starting an experiment, defining the goal and optional evaluation or data directories.

```python
solution = kapso.evolve(
    goal="Build a classifier with 95% accuracy",
    eval_dir="./evaluation/",  # Optional: user-provided evaluation
    data_dir="./data/",        # Optional: user-provided data
    max_iterations=10,
)
```

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

### SelectorAgent explain() method and usage

Source: https://docs.leeroo.com/docs/deployment/api-reference

Get a human-readable explanation of the deployment selection process.

```python
def explain(self, solution: SolutionResult) -> str
```

```python
selector = SelectorAgent()
explanation = selector.explain(solution)
print(explanation)
# Deployment Selection Analysis
# ========================================
# 
# Strategy:  modal
# Interface: function
# Provider:  modal
# Resources: {'gpu': 'T4', 'memory': '16Gi'}
# 
# Reasoning: GPU workload detected (torch dependency)
```

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

### Example agent output format

Source: https://docs.leeroo.com/docs/evolve/coding-agents

A complete example of an agent response including natural language explanation followed by the required XML tags.

```text
I've implemented the random forest classifier. Here's what I did:

1. Created main.py with the classifier implementation
2. Added data loading and preprocessing
3. Created kapso_evaluation/evaluate.py to test accuracy

<code_changes_summary>Implemented random forest classifier with
GridSearchCV for hyperparameter tuning. Added cross-validation and
accuracy reporting.</code_changes_summary>
<evaluation_script_path>kapso_evaluation/evaluate.py</evaluation_script_path>
<evaluation_output>Loading data...
Training model...
Accuracy: 0.92</evaluation_output>
<score>0.92</score>
<technical_difficulties>none</technical_difficulties>
```

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

### Deploy software locally

Source: https://docs.leeroo.com/docs/reference/kapso-api

Example of deploying a solution using the LOCAL strategy, running it with input data, and stopping the deployment.

```python
deployed = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)
result = deployed.run({"data_path": "./test.csv"})
deployed.stop()
```

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

### kapso research command examples

Source: https://docs.leeroo.com/docs/reference/cli

Examples of running deep web research with various objectives, modes, and depth settings.

```bash
kapso research --objective "How to optimize transformers?"
kapso research --objective "LLM fine-tuning" --mode idea
kapso research --objective "RAG implementation" --mode idea --mode implementation
kapso research --objective-file topic.txt --mode study --depth deep
```

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

### Software.run_batch() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates processing a list of inputs and iterating over the results.

```python
results = deployed_program.run_batch([
    {"text": "hello"},
    {"text": "world"},
    {"text": "test"},
])

for result in results:
    print(result["output"])
```

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

### learn_knowledge usage example

Source: https://docs.leeroo.com/docs/reference/kapso-api

An example of calling kapso.learn_knowledge with a repository source and research findings.

```python
kapso.learn_knowledge(
    Source.Repo("https://github.com/huggingface/trl"),
    findings,
    wiki_dir="data/wikis",
)
```

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

### Creating deployed Software instances with DeploymentFactory

Source: https://docs.leeroo.com/docs/deployment/api-reference

Examples of using DeploymentFactory.create to deploy with auto-selection, forced strategies, or restricted strategy lists.

```python
from kapso.deployment import DeploymentFactory, DeployStrategy, DeployConfig

config = DeployConfig(
    solution=my_solution,
    env_vars={"API_KEY": "xxx"},
    timeout=300,
)

# Auto-select best strategy
deployed_program = DeploymentFactory.create(DeployStrategy.AUTO, config)

# Force specific strategy
deployed_program = DeploymentFactory.create(DeployStrategy.MODAL, config)

# Restrict to certain strategies
deployed_program = DeploymentFactory.create(
    DeployStrategy.AUTO, 
    config,
    strategies=["local", "docker"]
)
```

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

### CLI commands for knowledge base learner

Source: https://docs.leeroo.com/docs/knowledge/learning-pipeline

Examples of how to run the learner module from the command line with various options like branch specification, extraction-only mode, and custom directories.

```bash
# Learn from a GitHub repository
python -m kapso.knowledge_base.learners https://github.com/user/repo

# Specify a branch
python -m kapso.knowledge_base.learners https://github.com/user/repo --branch develop

# Extract only (don't merge)
python -m kapso.knowledge_base.learners https://github.com/user/repo --extract-only

# Custom wiki directory
python -m kapso.knowledge_base.learners https://github.com/user/repo --wiki-dir ./my_wikis

# Verbose logging
python -m kapso.knowledge_base.learners https://github.com/user/repo --verbose
```

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

### Manage Infrastructure for Search Backends

Source: https://docs.leeroo.com/docs/knowledge/overview

Use the provided scripts to start or stop the Weaviate and Neo4j database infrastructure required by the search backends.

```bash
# Start Weaviate and Neo4j
./scripts/start_infra.sh

# Stop infrastructure
./scripts/stop_infra.sh
```

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

### Initialize and Run KnowledgeMerger

Source: https://docs.leeroo.com/docs/knowledge/learning-pipeline

Example of how to instantiate the KnowledgeMerger and execute a merge operation on a set of proposed pages.

```python
from kapso.knowledge_base.learners import KnowledgeMerger

merger = KnowledgeMerger()
result = merger.merge(
    proposed_pages=pages,
    wiki_dir="data/wikis",
)

print(f"Created: {len(result.created)}")
print(f"Edited: {len(result.edited)}")
print(f"Failed: {len(result.failed)}")
```

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

### Execute Search Strategy in Python

Source: https://docs.leeroo.com/docs/evolve/search-strategies

Example of initializing and running a generic search strategy using the Kapso Python SDK.

```python
from kapso.execution.search_strategies import SearchStrategyFactory

strategy = SearchStrategyFactory.create(
    strategy_type="generic",
    problem_handler=handler,
    llm=llm,
    coding_agent_config=config,
    params={"ideation_timeout": 300},
)

strategy.run(context, budget_progress=0.0)
best = strategy.get_best_experiment()
```

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

### Index a knowledge graph

Source: https://docs.leeroo.com/docs/reference/kapso-api

Example of indexing a wiki directory and initializing a Kapso instance with the resulting index path.

```python
index_path = kapso.index_kg(
    wiki_dir="data/wikis",
    save_to="data/indexes/finetuning.index",
)

kapso = Kapso(kg_index=index_path)
```

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

### Strategy config.yaml Structure

Source: https://docs.leeroo.com/docs/deployment/architecture

Example configuration file defining the provider, runner class, and resource requirements for a strategy.

```yaml
name: modal
provider: modal
interface: function

runner_class: ModalRunner

default_resources:
  gpu: T4
  memory: 16Gi

run_interface:
  type: modal
  function_name: predict
```

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

### Example usage of kapso.research

Source: https://docs.leeroo.com/docs/reference/kapso-api

A practical example of calling the research function with a specific objective, mode, and depth.

```python
findings = kapso.research(
    "QLoRA fine-tuning memory optimizations",
    mode=["idea", "implementation"],
    depth="deep",
)
```

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

### Deploy with Docker Strategy

Source: https://docs.leeroo.com/docs/deployment/strategies

Deploys the solution in a container. Requires Docker to be installed and running.

```python
deployed = kapso.deploy(solution, strategy=DeployStrategy.DOCKER)
```

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

### Configure Evolve mode

Source: https://docs.leeroo.com/docs/evolve/overview

Example of setting the evolution mode to MINIMAL using the kapso.evolve function.

```python
# Use a specific mode
solution = kapso.evolve(
    goal="...",
    mode="MINIMAL",
)
```

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

### Example .index file structure

Source: https://docs.leeroo.com/docs/knowledge/search-backends

The .index file is a JSON reference containing metadata about the data source and backend configuration.

```json
{
  "version": "1.0",
  "created_at": "2026-01-15T10:30:00Z",
  "data_source": "data/wikis",
  "search_backend": "kg_graph_search",
  "backend_refs": {
    "weaviate_collection": "KapsoKG",
    "embedding_model": "text-embedding-3-large"
  },
  "page_count": 99
}
```

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

### Implement Runner Class

Source: https://docs.leeroo.com/docs/deployment/adding-strategies

Example of a runner.py file implementing the Runner class for a custom strategy.

```python
from kapso.deployment.strategies.base import Runner
from typing import Any, Dict

class MyStrategyRunner(Runner):
    """Runner for my custom strategy."""

    def __init__(
        self,
        code_path: str,
        module: str = "main",
        callable: str = "predict",
        **kwargs,
    ):
        self.code_path = code_path
        self.module = module
        self.callable = callable
        self._running = False

    def run(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
        """Execute with inputs."""
        if not self._running:
            self.start()

        try:
            # Your execution logic here
            result = self._execute(inputs)
            return {"status": "success", "output": result}
        except Exception as e:
            return {"status": "error", "error": str(e)}

    def start(self) -> None:
        """Start the service."""
        # Initialize resources
        self._running = True

    def stop(self) -> None:
        """Stop and cleanup."""
        # Cleanup resources
        self._running = False

    def is_healthy(self) -> bool:
        """Check if service is running."""
        return self._running

    def get_logs(self) -> str:
        """Return execution logs."""
        return ""

    def _execute(self, inputs: Dict) -> Any:
        """Internal execution logic."""
        # Implement your execution here
        pass
```

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

### Run an evolve campaign

Source: https://docs.leeroo.com/docs/reference/kapso-api

Example usage of the kapso.evolve function to build a machine learning model, followed by printing the explanation of the resulting solution.

```python
solution = kapso.evolve(
    goal="Build a random forest classifier for Iris with accuracy > 0.9",
    max_iterations=10,
    output_path="./iris_solution",
)
print(solution.explain())
```

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

### Deploy with BentoML strategy

Source: https://docs.leeroo.com/docs/deployment/strategies

Packages the solution as a BentoML service for self-hosted production serving. Requires the bentoml package to be installed.

```python
deployed = kapso.deploy(solution, strategy=DeployStrategy.BENTOML)
```

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

### Check setup with kapso doctor output

Source: https://docs.leeroo.com/docs/installation

The doctor command reports configuration requirements and identifies missing dependencies.

```bash
kapso doctor
```

```text
kapso doctor
====================================================================
  [OK ] node
  [OK ] codex CLI
  [OK ] codex authenticated
  [OK ] claude CLI
  [OK ] claude authenticated
  [OK ] git
  [OK ] OPENAI_API_KEY (embeddings)
  [OK ] deploy target docker
  [-- ] deploy target modal
         needed by  only needed for deploy(strategy=DeployStrategy.MODAL)
         fix        pip install modal && modal token new
====================================================================
Required checks passed (9 checked). 1 optional item(s) marked [-- ] only limit features you may not need.
```

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

### Constructing a coding agent manually

Source: https://docs.leeroo.com/docs/evolve/coding-agents

Example of using the CodingAgentFactory to build a configuration and instantiate an agent for a specific workspace.

```python
from kapso.execution.coding_agents.factory import CodingAgentFactory

config = CodingAgentFactory.build_config(
    agent_type="claude_code",
    model="claude-opus-5",
)

agent = CodingAgentFactory.create(config)
agent.initialize("/path/to/workspace")

result = agent.generate_code("Implement a sorting algorithm")
print(f"Files changed: {result.files_changed}")
print(f"Cost: ${result.cost:.4f}")
```

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

### Initialize Kapso with configuration paths

Source: https://docs.leeroo.com/docs/reference/configuration

Demonstrates how to initialize the Kapso client using either the default packaged configuration or a custom path.

```python
from kapso import Kapso

kapso = Kapso()                              # packaged config
kapso = Kapso(config_path="./my-config.yaml")  # yours
```

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

### Initialize and use kg_llm_navigation

Source: https://docs.leeroo.com/docs/knowledge/search-backends

Demonstrates how to create a search instance using the kg_llm_navigation factory, index JSON data, and perform a search query.

```python
import json
from kapso.knowledge_base.search import KnowledgeSearchFactory

search = KnowledgeSearchFactory.create("kg_llm_navigation")

with open("kg_data.json") as handle:
    search.index(json.load(handle))

result = search.search(
    query="Best practices for feature engineering",
    context="Working on a tabular data competition",
)
```

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

### Install Leeroopedia MCP

Source: https://docs.leeroo.com/docs/installation

Installs the Leeroopedia MCP package via pip.

```bash
pip install leeroopedia-mcp
```

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

### Run Kapso evolve and deploy

Source: https://docs.leeroo.com/docs/evolve/overview

Demonstrates initializing a Kapso instance, evolving a solution with specific goals and optional data/evaluation directories, and deploying the resulting program locally.

```python
from kapso import Kapso, DeployStrategy

kapso = Kapso()

# Build a solution - agent builds evaluation dynamically
# Include success criteria in the goal
solution = kapso.evolve(
    goal="Build a random forest classifier for Iris with accuracy > 0.9",
    max_iterations=10,
)

# With user-provided evaluation and data
solution = kapso.evolve(
    goal="Optimize model inference speed to < 10ms",
    eval_dir="./my_evaluation/",   # Copied to kapso_evaluation/
    data_dir="./my_data/",         # Copied to kapso_datasets/
    initial_repo="https://github.com/org/starter",  # Or local path
)

# Deploy and run
deployed_program = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)
result = deployed_program.run({"data_path": "./test.csv"})
```

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

### kapso --list-agents

Source: https://docs.leeroo.com/docs/reference/cli

Lists the available coding agents, including their associated models and installation commands.

```APIDOC
## kapso --list-agents

### Description
Lists the available coding agents with their models and install commands.

### Usage
`kapso --list-agents`
```

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

### Bootstrap from existing repo

Source: https://docs.leeroo.com/docs/evolve/repo-memory

Initializes a baseline model for the repository using an LLM backend.

```python
from kapso.core.llm import LLMBackend

llm = LLMBackend()

# Build evidence-backed model via LLM
RepoMemoryManager.bootstrap_baseline_model(
    repo_root="/path/to/repo",
    llm=llm,
    initial_repo="/original/repo",
    max_retries=2,
)
```

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

### Install RelBench dependencies

Source: https://docs.leeroo.com/docs/benchmarks/relbench

Commands to install the evaluation layer and the modeling stack for RelBench.

```bash
pip install relbench duckdb pooch pyarrow scikit-learn   # evaluation layer
pip install "relbench[full]" sentence-transformers \
    lightgbm xgboost catboost tqdm                   # modeling stack (GPU machine)
```

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

### kapso watch command usage

Source: https://docs.leeroo.com/docs/reference/cli

Examples of monitoring evolve, learn, or learn_knowledge operations using the watch command with various flags.

```bash
kapso watch ./campaign
kapso watch learning/status
kapso watch ./campaign --follow
kapso watch ./campaign --json | jq -r '[.state] | @tsv'
```

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

### Indexing corpora with kapso index_kg

Source: https://docs.leeroo.com/docs/reference/cli

Examples of indexing wiki directories or JSON data files into a knowledge graph, with options to force overwrite existing data.

```bash
kapso index_kg --wiki-dir ./data/wikis --save-to ./data/indexes/ml.index
kapso index_kg --data-path ./data/kg_data.json --save-to ./data/indexes/kaggle.index
kapso index_kg --wiki-dir ./data/wikis --save-to ./data/indexes/ml.index --force
```

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

### Install OpenHands environment

Source: https://docs.leeroo.com/docs/evolve/coding-agents

Commands to create a dedicated Conda environment and install OpenHands dependencies.

```bash
conda create -n openhands_env python=3.12
conda activate openhands_env
pip install openhands-ai litellm
```

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

### Create adapter_instruction.txt

Source: https://docs.leeroo.com/docs/deployment/adding-strategies

Defines adaptation instructions, required files, and the entry point format for the strategy.

```markdown
## Adaptation Instructions for My Strategy

### Required Files

1. `run.py` - Entry point script
2. `requirements.txt` - Dependencies

### Entry Point Format

```python
def predict(inputs: dict) -> dict:
    """Main prediction function."""
    # Implementation
    return {"result": ...}
```

### Environment Variables

- `MY_STRATEGY_CONFIG` - Configuration path

### Notes

- Keep dependencies minimal
- Handle errors gracefully
```

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

### Run kapso doctor commands

Source: https://docs.leeroo.com/docs/reference/cli

Examples of running the doctor command to check configuration, optionally filtered by a specific verb or including model probes.

```bash
kapso doctor
kapso doctor evolve
kapso doctor evolve --models
```

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

### Kapso.deploy()

Source: https://docs.leeroo.com/docs/reference/kapso-api

Turns a solution into running software.

```APIDOC
## deploy()

### Description
Deploys a generated solution into a running software instance.

### Returns
- **Software** - The deployed software instance.
```

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

### Initialize bank repository

Source: https://docs.leeroo.com/docs/learning/bank

Creates the bank home as a bare repository with a founding skeleton.

```bash
kapso learn init-bank
```

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

### Install Claude Code CLI

Source: https://docs.leeroo.com/docs/evolve/coding-agents

Command to install the Anthropic Claude Code CLI globally via npm.

```bash
npm install -g @anthropic-ai/claude-code
```

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

### Kapso.learn()

Source: https://docs.leeroo.com/docs/reference/kapso-api

Mines a finished campaign into the lesson bank.

```APIDOC
## learn()

### Description
Mines data from a completed campaign into the lesson bank.

### Returns
- **LessonResult** - The result of the learning process.
```

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

### Initialize and execute kg_graph_search

Source: https://docs.leeroo.com/docs/knowledge/search-backends

Demonstrates how to instantiate the kg_graph_search backend using the KnowledgeSearchFactory and perform a search with specific filters.

```python
from kapso.knowledge_base.search import KnowledgeSearchFactory, KGSearchFilters

search = KnowledgeSearchFactory.create("kg_graph_search", params={
    "weaviate_collection": "KapsoKG",
    "embedding_model": "text-embedding-3-large",
    "use_llm_reranker": True,
})

result = search.search(
    query="How to fine-tune an LLM with limited GPU memory?",
    filters=KGSearchFilters(top_k=5, domains=["LLMs", "PEFT"]),
)

for item in result:
    print(f"{item.id}: {item.score:.2f}")

context = result.to_context_string(max_results=3)
```

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

### kapso learn init-bank

Source: https://docs.leeroo.com/docs/reference/cli

Initializes the bank home.

```APIDOC
## kapso learn init-bank

### Description
Creates the bank home.

### Parameters
- **--config** (string) - Required - Configuration file
```

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

### Deploy a Kapso solution

Source: https://docs.leeroo.com/docs/deployment/overview

Demonstrates the full lifecycle of deploying a solution, including strategy selection, running inference, and lifecycle management.

```python
from kapso import Kapso, DeployStrategy

kapso = Kapso()
solution = kapso.evolve(goal="Build a classifier")

# Deploy with explicit strategy
deployed_program = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)

# Run inference
result = deployed_program.run({"data_path": "./test.csv"})
print(result)  # {"status": "success", "output": ...}

# Lifecycle management
deployed_program.stop()
deployed_program.start()
deployed_program.stop()
```

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

### Software.is_healthy() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates checking health before executing a run.

```python
if deployed_program.is_healthy():
    result = deployed_program.run(inputs)
else:
    print("Software not healthy!")
```

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

### Software.run(inputs: Dict) -> Dict

Source: https://docs.leeroo.com/docs/deployment/overview

Executes the deployment with the provided input data and returns a status object.

```APIDOC
## Software.run(inputs)

### Description
Executes the deployment with the provided input data.

### Parameters
- **inputs** (Dict) - Required - Input data for the execution.

### Response
- **status** (string) - "success" or "error"
- **output** (any) - Result of the execution (on success)
- **error** (string) - Error message (on error)
```

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

### Software.__call__() shorthand

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates that calling the instance directly is equivalent to calling run().

```python
# These are equivalent
result = deployed_program.run(inputs)
result = deployed_program(inputs)
```

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

### get_endpoint() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates how to retrieve and print the API endpoint if it exists.

```python
endpoint = deployed_program.get_endpoint()
if endpoint:
    print(f"API available at: {endpoint}")
```

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

### get_adapted_path() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates how to call get_adapted_path() and print the resulting path.

```python
path = deployed_program.get_adapted_path()
print(path)  # "/path/to/solution_adapted_modal"
```

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

### Enable serving configuration

Source: https://docs.leeroo.com/docs/learning/serving

Configure the learning module to enable serving and specify the local path for the bank.

```yaml
learning:
  serving:
    enabled: true
  bank:
    local_path: data/kapso-bank.git
```

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

### Deploying a solution

Source: https://docs.leeroo.com/docs/quickstart

Deploy a solution using a specified strategy and run it with input data. DeployStrategy options include LOCAL, DOCKER, MODAL, BENTOML, and LANGGRAPH.

```python
from kapso import Kapso, DeployStrategy

deployed = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)
result = deployed.run({"data_path": "./test.csv"})
deployed.stop()
```

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

### Software.stop() usage example

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates stopping a program and verifying its health status.

```python
deployed_program.stop()
print(deployed_program.is_healthy())  # False
```

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

### Deploy with LOCAL strategy

Source: https://docs.leeroo.com/docs/deployment/strategies

Runs the solution as a plain Python process in the current environment. This strategy is best for development and debugging as it offers no isolation.

```python
deployed = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)
result = deployed.run({"data_path": "./data.csv"})
```

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

### Workspace directory structure

Source: https://docs.leeroo.com/docs/evolve/overview

Visual representation of the workspace layout after Evolve setup.

```text
workspace/
├── kapso_evaluation/     # Agent builds evaluation here
│   └── evaluate.py       # Evaluation script
├── kapso_datasets/       # Data files (from data_dir)
├── .kapso/
│   └── repo_memory.json  # Codebase understanding
└── (solution code)       # From initial_repo or agent-built
```

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

### Manage deployment lifecycle with kapso.deploy

Source: https://docs.leeroo.com/docs/deployment/overview

Demonstrates how to deploy a program, check its health, and perform stop/start operations for resource cleanup.

```python
deployed_program = kapso.deploy(solution, strategy=DeployStrategy.LOCAL)

# Initial run
result = deployed_program.run({"data": "..."})

# Check health
if deployed_program.is_healthy():
    print("Service is running")

# Stop (cleanup resources)
deployed_program.stop()

# Restart
deployed_program.start()

# Run again
result = deployed_program.run({"data": "..."})

# Final cleanup
deployed_program.stop()
```

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

### Get specific section

Source: https://docs.leeroo.com/docs/evolve/repo-memory

Retrieves the text content of a specific section from the repository memory.

```python
# Read a section
section_text = RepoMemoryManager.get_section(doc, "core.architecture")
print(section_text)
```

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

### Context manager support

Source: https://docs.leeroo.com/docs/deployment/api-reference

Demonstrates using the deployment as a context manager to ensure automatic cleanup via stop().

```python
with DeploymentFactory.create(strategy, config) as deployed_program:
    result = deployed_program.run(inputs)
# deployed_program.stop() called automatically
```

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

### Create selector_instruction.txt

Source: https://docs.leeroo.com/docs/deployment/adding-strategies

Provides documentation for auto-selection, including summary, usage conditions, and requirements.

```markdown
## My Strategy

### Summary

A custom deployment strategy for [specific use case].

### When to Use

- Condition 1
- Condition 2
- Condition 3

### When NOT to Use

- Anti-condition 1
- Anti-condition 2

### Requirements

- Requirement 1
- Requirement 2
```

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

### Get cumulative cost with Orchestrator

Source: https://docs.leeroo.com/docs/evolve/overview

Retrieves the total cost tracked by the orchestrator across all components.

```python
# Get cumulative cost
cost = orchestrator.get_cumulative_cost()
print(f"Total cost: ${cost:.2f}")
```

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

### kapso learn develop command

Source: https://docs.leeroo.com/docs/reference/cli

Runs a development session with a split manifest and learner version.

```bash
kapso learn develop --split splits/d1.yaml --learner-version v3
```

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

### Kapso Constructor

Source: https://docs.leeroo.com/docs/reference/kapso-api

Initializes a new Kapso instance with optional configuration, knowledge graph index, and lesson bank path.

```APIDOC
## Kapso(config_path: str | None = None, kg_index: str | None = None, bank: str | None = None)

### Description
Initializes the Kapso client. If no arguments are provided, it defaults to the packaged config.yaml.

### Parameters
- **config_path** (str | None) - Optional - Path to a config file.
- **kg_index** (str | None) - Optional - Path to an existing .index file. Without one, knowledge search is disabled.
- **bank** (str | None) - Optional - Lesson-bank home directory, overriding the default config path.
```

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

### Claude Code configuration block

Source: https://docs.leeroo.com/docs/evolve/coding-agents

Example configuration for the Claude Code agent, specifying the model and authentication mode.

```yaml
coding_agent:
  type: "claude_code"
  model: "claude-opus-5"
  agent_specific:
    auth_mode: "oauth"
    claude_md_path: "CLAUDE.md"
```

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

### DeploymentFactory.explain_strategy()

Source: https://docs.leeroo.com/docs/deployment/api-reference

Retrieves a one-line description for a specific deployment strategy.

```APIDOC
## DeploymentFactory.explain_strategy()

### Description
Get explanation of a deployment strategy.

### Signature
```python
@classmethod
def explain_strategy(cls, strategy: str) -> str
```

### Parameters
- **strategy** (str) - Required - Strategy name

### Returns
- **str** - One-line description from selector instruction
```
Tokens:
Raw