### Install ScaleDown packages

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Commands to install the core library and optional optimizer modules.

```bash
pip install scaledown
```

```bash
pip install scaledown[haste]
```

```bash
pip install scaledown[semantic]
```

```bash
pip install scaledown[haste,semantic]
```

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

### Perform development installation

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Steps to set up a local development environment for ScaleDown.

```bash
git clone https://github.com/scaledown-team/scaledown.git
cd scaledown
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install -e ".[haste,semantic]"
```

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

### Installing and Running Tests

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Install pytest and run the ScaleDown test suite. Supports running all tests or specific test modules for targeted debugging.

```bash
# Install test dependencies
pip install pytest

# Run all tests
pytest -v

# Run specific test modules
pytest tests/test_pipeline.py -v
pytest tests/test_compressor.py -v
pytest tests/test_haste.py -v
pytest tests/test_semantic.py -v
```

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

### Conversation Summarization

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Utilize ScaleDownCompressor to summarize long conversation logs. The 'auto' rate setting dynamically adjusts compression, and the prompt guides the summary's focus.

```python
from scaledown import ScaleDownCompressor

compressor = ScaleDownCompressor(rate="auto")
conversations = ["Long chat log 1...", "Long chat log 2..."]
summaries = compressor.compress(
    context=conversations,
    prompt="Summarize in 2 sentences"
)
```

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

### Initialize and Run Pipeline

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Set up a Pipeline by chaining HasteOptimizer, SemanticOptimizer, and ScaleDownCompressor. Execute the pipeline with a query, file path, and final prompt.

```python
from scaledown import Pipeline
from scaledown.optimizer import HasteOptimizer, SemanticOptimizer
from scaledown import ScaleDownCompressor

pipeline = Pipeline([
    ('code_selection', HasteOptimizer(top_k=8)),
    ('semantic_filter', SemanticOptimizer(top_k=4)),
    ('compression', ScaleDownCompressor(target_model="gpt-4o"))
])

result = pipeline.run(
    query="data validation logic",
    file_path="validators.py",
    prompt="Explain the validation flow"
)
```

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

### Initialize HasteOptimizer

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Configure the AST-guided optimizer for intelligent code extraction from large files.

```python
from scaledown.optimizer import HasteOptimizer

# Initialize optimizer
optimizer = HasteOptimizer(
    top_k=6,           # Number of top functions/classes to retrieve
    prefilter=300,     # Size of candidate pool before reranking
    bfs_depth=1,       # BFS expansion depth over call graph
    max_add=12,        # Maximum nodes added during BFS expansion
    semantic=False,    # Enable semantic reranking with embeddings
    sem_model='text-embedding-3-small',  # OpenAI embedding model
    hard_cap=1200,     # Hard token limit for output
    soft_cap=1800,     # Soft token target for output
    target_model="gpt-4o"
)
```

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

### Code Documentation Generation

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Use HasteOptimizer to optimize code for documentation generation. This snippet demonstrates initializing the optimizer and running it on a specified file.

```python
from scaledown.optimizer import HasteOptimizer

optimizer = HasteOptimizer(top_k=10)
result = optimizer.optimize(
    query="API endpoints",
    file_path="api.py"
)
# Feed to LLM for documentation generation
```

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

### Initialize ScaleDownCompressor

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Instantiate ScaleDownCompressor with target model and compression rate. Useful for API-powered prompt compression with optional keyword preservation.

```python
compressor = ScaleDownCompressor(
    target_model="gpt-4o",
    rate="auto",
    preserve_keywords=True
)
result = compressor.compress(
    context="Long conversation history...",
    prompt="What were the action items?"
)
```

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

### Compress prompts with ScaleDownCompressor

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Initialize and use the compressor for single prompt-context pairs to reduce token usage.

```python
from scaledown import ScaleDownCompressor

# Initialize compressor
compressor = ScaleDownCompressor(
    target_model="gpt-4o",       # Target LLM model
    rate="auto",                  # Compression rate ("auto" or specific ratio)
    preserve_keywords=True,       # Preserve important keywords
    preserve_words=["API", "authentication"]  # Specific words to preserve
)

# Single compression
context = """
The authentication system uses JWT tokens for stateless session management.
When a user logs in, the server validates credentials against the database,
generates a signed JWT containing the user ID and roles, and returns it.
Subsequent requests must include the token in the Authorization header.
The middleware validates the token signature and extracts user information.
"""
prompt = "Explain the authentication flow"

result = compressor.compress(context=context, prompt=prompt)

print(f"Compressed: {result.content}")
print(f"Original tokens: {result.tokens[0]}")
print(f"Compressed tokens: {result.tokens[1]}")
print(f"Savings: {result.savings_percent:.1f}%")
print(f"Latency: {result.latency}ms")
```

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

### ScaleDownCompressor Batch Processing

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Demonstrates batch processing for ScaleDownCompressor where multiple contexts are compressed with corresponding prompts in parallel.

```python
compressor = ScaleDownCompressor(target_model="gpt-4o")

# Batch mode (parallel contexts)
contexts = ["Context A...", "Context B...", "Context C..."]
prompts = ["Query A", "Query B", "Query C"]
results = compressor.compress(context=contexts, prompt=prompts)

# Broadcast mode (same prompt for all contexts)
results = compressor.compress(
    context=["Doc 1", "Doc 2", "Doc 3"],
    prompt="Summarize key points"
)
```

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

### Initialize HasteOptimizer

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Instantiate HasteOptimizer with custom parameters for AST-guided code selection. Useful for fine-tuning retrieval and reranking processes.

```python
optimizer = HasteOptimizer(
    top_k=10,
    semantic=True,
    hard_cap=2000
)
result = optimizer.optimize(
    context="",
    query="find database queries",
    file_path="database.py"
)
```

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

### Initialize HasteOptimizer with semantic mode

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Enables semantic reranking for improved relevance in code searches.

```python
from scaledown.optimizer import HasteOptimizer

# Initialize with semantic search enabled
optimizer = HasteOptimizer(
    top_k=10,
    semantic=True,                        # Enable semantic reranking
    sem_model='text-embedding-3-small',   # OpenAI embedding model
    hard_cap=2000
)

result = optimizer.optimize(
    context="",
    query="find database connection and query execution logic",
    file_path="database.py"
)

print(f"Retrieved {result.metrics.chunks_retrieved} relevant code chunks")
print(f"Mode: {result.metrics.retrieval_mode}")  # Output: "hybrid"
```

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

### Create pipelines with make_pipeline helper

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Provides a cleaner syntax for defining and running multi-stage pipelines.

```python
from scaledown import make_pipeline, ScaleDownCompressor
from scaledown.optimizer import HasteOptimizer

# Create pipeline using helper
pipeline = make_pipeline([
    ('haste', HasteOptimizer(top_k=5, semantic=True)),
    ('compress', ScaleDownCompressor(rate="auto"))
])

result = pipeline.run(
    context="",
    query="API endpoints",
    file_path="api.py",
    prompt="Document the API structure"
)

# Access a specific step
haste_step = pipeline.get_step('haste')
print(f"Pipeline: {pipeline}")  # Output: Pipeline(steps=['haste', 'compress'])
```

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

### Run a full optimization and compression pipeline

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Chains multiple optimizers and a compressor to maximize token efficiency.

```python
import scaledown as sd
from scaledown.optimizer import HasteOptimizer, SemanticOptimizer
from scaledown import ScaleDownCompressor, Pipeline

# Define pipeline stages
pipeline = Pipeline([
    ('haste', HasteOptimizer(top_k=5)),
    ('semantic', SemanticOptimizer(top_k=3)),
    ('compressor', ScaleDownCompressor(target_model="gpt-4o"))
])

# Run pipeline
result = pipeline.run(
    query="explain error handling",
    file_path="app.py",
    prompt="Provide a concise summary"
)

print(f"Original: {result.metrics.original_tokens} tokens")
print(f"Final: {result.metrics.total_tokens} tokens")
print(f"Savings: {result.savings_percent:.1f}%")
print(f"\nOptimized Content:\n{result.final_content}")
```

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

### Initialize SemanticOptimizer

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Create a SemanticOptimizer instance with a specified embedding model and top-k value. Ideal for local embedding-based code search.

```python
optimizer = SemanticOptimizer(
    model_name="Qwen/Qwen3-Embedding-0.6B",
    top_k=5
)
result = optimizer.optimize(
    context="",
    query="authentication middleware",
    file_path="auth.py"
)
```

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

### Large Codebase Q&A Pipeline

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Set up a ScaleDown pipeline for Q&A on large codebases, combining SemanticOptimizer and ScaleDownCompressor. This allows for efficient querying of code functionality.

```python
from scaledown import Pipeline
from scaledown.optimizer import SemanticOptimizer
from scaledown import ScaleDownCompressor

pipeline = Pipeline([
    ('semantic', SemanticOptimizer(top_k=5)),
    ('compress', ScaleDownCompressor())
])

result = pipeline.run(
    query="authentication flow",
    file_path="auth.py",
    prompt="How does the authentication work?"
)
```

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

### Compress prompts using ScaleDownCompressor

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Compresses input text and prompts using the ScaleDown API.

```python
from scaledown import ScaleDownCompressor

compressor = ScaleDownCompressor(
    target_model="gpt-4o",
    rate="auto"
)

context = "Your long document or conversation history..."
prompt = "Summarize the main points in 3 bullet points."

result = compressor.compress(context=context, prompt=prompt)

print(result)  # Compressed prompt
print(f"Token reduction: {result.metrics.original_prompt_tokens} → {result.metrics.compressed_prompt_tokens}")
```

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

### Chain optimizers and compressors with Pipeline

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Combines multiple stages for token reduction, ensuring optimizers precede compressors.

```python
from scaledown import Pipeline, ScaleDownCompressor
from scaledown.optimizer import HasteOptimizer, SemanticOptimizer

# Define pipeline with multiple stages
pipeline = Pipeline([
    ('code_selection', HasteOptimizer(top_k=8)),
    ('semantic_filter', SemanticOptimizer(top_k=4)),
    ('compression', ScaleDownCompressor(target_model="gpt-4o"))
])

# Run pipeline
result = pipeline.run(
    context="",                              # Initial context (or file content)
    query="data validation logic",           # Query for optimizers
    file_path="validators.py",               # Code file to analyze
    prompt="Explain the validation flow"     # Prompt for compressor
)

# Access results
print(f"Final Content:\n{result.final_content}")
print(f"Original tokens: {result.original_tokens}")
print(f"Final tokens: {result.final_tokens}")
print(f"Total savings: {result.savings_percent:.1f}%")
print(f"Compression ratio: {result.total_compression_ratio:.2f}x")

# Inspect each step
for step in result.history:
    print(f"{step.step_name}: {step.input_tokens} -> {step.output_tokens} tokens "
          f"({step.compression_ratio:.2f}x, {step.latency_ms:.0f}ms)")
```

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

### Configure API credentials

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Methods for setting the API key via environment variables or Python code.

```bash
export SCALEDOWN_API_KEY="sk-your-api-key-here"
export SCALEDOWN_API_URL="https://api.scaledown.xyz"  # Optional, uses default if not set
```

```python
import scaledown as sd

sd.set_api_key("sk-your-api-key-here")
```

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

### Optimize Context with HasteOptimizer

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Employ HasteOptimizer for context optimization, providing metrics such as content, compression ratio, original and optimized token counts, latency, and retrieval details.

```python
from scaledown.optimizer import HasteOptimizer

optimizer = HasteOptimizer(top_k=5)
result = optimizer.optimize(
    context="",
    query="main function",
    file_path="app.py"
)

# OptimizedContext properties
print(f"Content: {result.content}")
print(f"Compression ratio: {result.compression_ratio:.2f}x")

# OptimizerMetrics
metrics = result.metrics
print(f"Original tokens: {metrics.original_tokens}")
print(f"Optimized tokens: {metrics.optimized_tokens}")
print(f"Chunks retrieved: {metrics.chunks_retrieved}")
print(f"Latency: {metrics.latency_ms}ms")
print(f"Retrieval mode: {metrics.retrieval_mode}")
print(f"AST fidelity: {metrics.ast_fidelity}")
```

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

### Configure ScaleDown API key

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Methods for setting the global API key programmatically or via environment variables.

```python
import scaledown as sd

# Set API key programmatically
sd.set_api_key("sk-your-api-key-here")

# Or use environment variable
import os
os.environ["SCALEDOWN_API_KEY"] = "sk-your-api-key-here"
```

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

### ScaleDownCompressor API

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

API-powered prompt compression service.

```APIDOC
## ScaleDownCompressor

### Description
API-powered prompt compression service.

### Parameters
- `target_model` (str, default="gpt-4o"): Target LLM model for compression
- `rate` (str, default="auto"): Compression rate ("auto" or specific ratio)
- `api_key` (str, optional): API key (reads from environment if not provided)
- `temperature` (float, optional): Sampling temperature for compression
- `preserve_keywords` (bool, default=False): Preserve specific keywords
- `preserve_words` (list, optional): List of words to preserve during compression

### Methods
- `compress(context, prompt, max_tokens=None, **kwargs)`: Compress prompt via API
  - `context` (str or List[str]): Context to compress
  - `prompt` (str or List[str]): Query prompt
  - `max_tokens` (int, optional): Maximum tokens in output
  - Returns: `CompressedPrompt` or `List[CompressedPrompt]`

### Batch Processing
```python
compressor = ScaleDownCompressor(target_model="gpt-4o")

# Batch mode (parallel contexts)
contexts = ["Context A...", "Context B...", "Context C..."]
prompts = ["Query A", "Query B", "Query C"]
results = compressor.compress(context=contexts, prompt=prompts)

# Broadcast mode (same prompt for all contexts)
results = compressor.compress(
    context=["Doc 1", "Doc 2", "Doc 3"],
    prompt="Summarize key points"
)
```

### Request Example
```python
compressor = ScaleDownCompressor(
    target_model="gpt-4o",
    rate="auto",
    preserve_keywords=True
)
result = compressor.compress(
    context="Long conversation history...",
    prompt="What were the action items?"
)
```
```

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

### Pipeline API

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Chain multiple optimizers and compressors.

```APIDOC
## Pipeline

### Description
Chain multiple optimizers and compressors.

### Constructor
- `Pipeline(steps)`: Create pipeline from list of (name, component) tuples

### Methods
- `run(query, file_path, prompt, context="", **kwargs)`: Execute pipeline
  - `query` (str): Query for optimizers
  - `file_path` (str): Path to code file for optimizers
  - `prompt` (str): Final prompt for compressor
  - `context` (str, optional): Initial context
  - Returns: `PipelineResult` with `.final_content`, `.metrics`, `.history`

### Request Example
```python
from scaledown import Pipeline
from scaledown.optimizer import HasteOptimizer, SemanticOptimizer
from scaledown import ScaleDownCompressor

pipeline = Pipeline([
    ('code_selection', HasteOptimizer(top_k=8)),
    ('semantic_filter', SemanticOptimizer(top_k=4)),
    ('compression', ScaleDownCompressor(target_model="gpt-4o"))
])

result = pipeline.run(
    query="data validation logic",
    file_path="validators.py",
    prompt="Explain the validation flow"
)
```
```

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

### Execute a Pipeline with ScaleDown

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Utilize the Pipeline class to chain optimization and compression steps. The PipelineResult provides the final content, token counts, compression metrics, and detailed history for each step.

```python
from scaledown import Pipeline, ScaleDownCompressor
from scaledown.optimizer import HasteOptimizer

pipeline = Pipeline([
    ('optimize', HasteOptimizer(top_k=5)),
    ('compress', ScaleDownCompressor())
])

result = pipeline.run(
    context="",
    query="error handling",
    file_path="app.py",
    prompt="Analyze error handling"
)

# PipelineResult properties
print(f"Final content: {result.final_content}")
print(f"Original tokens: {result.original_tokens}")
print(f"Final tokens: {result.final_tokens}")
print(f"Total compression: {result.total_compression_ratio:.2f}x")
print(f"Savings: {result.savings_percent:.1f}%")

# StepMetadata for each step
for step in result.history:
    print(f"Step: {step.step_name}")
    print(f"  Input: {step.input_tokens} tokens")
    print(f"  Output: {step.output_tokens} tokens")
    print(f"  Ratio: {step.compression_ratio:.2f}x")
    print(f"  Latency: {step.latency_ms}ms")
    print(f"  Details: {step.details}")
```

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

### Optimize code context with HasteOptimizer

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Basic usage of the optimizer to retrieve relevant code chunks from a file.

```python
result = optimizer.optimize(
    context="",                           # Can be empty when file_path provided
    query="explain the training loop",    # Search query for relevant code
    file_path="train.py"                  # Path to Python file to analyze
)

print(f"Optimized Code:\n{result.content}")
print(f"Original tokens: {result.metrics.original_tokens}")
print(f"Optimized tokens: {result.metrics.optimized_tokens}")
print(f"Compression ratio: {result.metrics.compression_ratio:.2f}x")
print(f"Chunks retrieved: {result.metrics.chunks_retrieved}")
print(f"Retrieval mode: {result.metrics.retrieval_mode}")
```

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

### Optimize code with HasteOptimizer

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Extracts relevant code sections using AST-guided search.

```python
from scaledown.optimizer import HasteOptimizer

optimizer = HasteOptimizer(top_k=5, semantic=False)

result = optimizer.optimize(
    context="",  # Can be empty when file_path is provided
    query="explain the training loop",
    file_path="train.py"
)

print(result.content)  # Optimized code
print(f"Compression: {result.metrics.compression_ratio:.2f}x")
```

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

### HasteOptimizer API

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

AST-guided code selection using Tree-sitter and hybrid search.

```APIDOC
## HasteOptimizer

### Description
AST-guided code selection using Tree-sitter and hybrid search.

### Parameters
- `top_k` (int, default=6): Number of top functions/classes to retrieve
- `prefilter` (int, default=300): Size of candidate pool before reranking
- `bfs_depth` (int, default=1): BFS expansion depth over call graph
- `max_add` (int, default=12): Maximum nodes added during BFS expansion
- `semantic` (bool, default=False): Enable semantic reranking with OpenAI embeddings
- `sem_model` (str, default='text-embedding-3-small'): OpenAI embedding model for semantic search
- `hard_cap` (int, default=1200): Hard token limit for output
- `soft_cap` (int, default=1800): Soft token target for output
- `target_model` (str, default="gpt-4o"): Target LLM for token counting

### Methods
- `optimize(context, query, file_path=None, max_tokens=None, **kwargs)`: Extract relevant code
  - `context` (str): Source code (can be empty if file_path provided)
  - `query` (str, required): Search query for relevant code
  - `file_path` (str, required): Path to Python file to analyze
  - `max_tokens` (int, optional): Override hard_cap for this call
  - Returns: `OptimizedContext` with `.content` and `.metrics`

### Request Example
```python
optimizer = HasteOptimizer(
    top_k=10,
    semantic=True,
    hard_cap=2000
)
result = optimizer.optimize(
    context="",
    query="find database queries",
    file_path="database.py"
)
```
```

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

### Perform batch prompt compression

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Process multiple context-prompt pairs in parallel or broadcast a single prompt across multiple contexts.

```python
from scaledown import ScaleDownCompressor

compressor = ScaleDownCompressor(target_model="gpt-4o")

# Batch mode: parallel contexts with matching prompts
contexts = [
    "User login conversation history...",
    "Support ticket discussion about billing...",
    "Technical troubleshooting chat log..."
]
prompts = [
    "Summarize the login issue",
    "Extract billing concerns",
    "List troubleshooting steps taken"
]

results = compressor.compress(context=contexts, prompt=prompts)

for i, result in enumerate(results):
    print(f"Result {i+1}: {result.tokens[0]} -> {result.tokens[1]} tokens")

# Broadcast mode: same prompt for all contexts
results = compressor.compress(
    context=["Document A", "Document B", "Document C"],
    prompt="Summarize key points in 2 sentences"
)
```

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

### Compress Text with ScaleDownCompressor

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Use ScaleDownCompressor to compress text and access detailed metrics about the operation, including content, token counts, compression ratio, savings, latency, and the model used.

```python
from scaledown import ScaleDownCompressor

compressor = ScaleDownCompressor(target_model="gpt-4o")
result = compressor.compress(
    context="Long context text...",
    prompt="Summarize this"
)

# CompressedPrompt properties
print(f"Content: {result.content}")           # Compressed text
print(f"Tokens: {result.tokens}")             # (original, compressed) tuple
print(f"Compression ratio: {result.compression_ratio:.2f}x")
print(f"Savings: {result.savings_percent:.1f}%")
print(f"Latency: {result.latency}ms")
print(f"Model: {result.model}")
```

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

### Perform embedding-based code search with SemanticOptimizer

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Uses sentence transformers and FAISS for local semantic similarity matching.

```python
from scaledown.optimizer import SemanticOptimizer

# Initialize optimizer
optimizer = SemanticOptimizer(
    model_name="Qwen/Qwen3-Embedding-0.6B",  # HuggingFace embedding model
    top_k=3,                                   # Number of top chunks to retrieve
    target_model="gpt-4o"                      # Target LLM for token counting
)

# Find semantically similar code
result = optimizer.optimize(
    context="",                            # Can be empty when file_path provided
    query="authentication middleware",      # Semantic search query
    file_path="auth.py"                    # Path to Python file
)

print(f"Relevant Code:\n{result.content}")
print(f"Original tokens: {result.metrics.original_tokens}")
print(f"Optimized tokens: {result.metrics.optimized_tokens}")
print(f"Chunks retrieved: {result.metrics.chunks_retrieved}")
print(f"Retrieval mode: {result.metrics.retrieval_mode}")  # "semantic_search"
```

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

### Accessing Pipeline Results

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Access the final content, savings percentage, and step-by-step history from a ScaleDown pipeline result. Useful for inspecting the output of optimization processes.

```python
print(result.final_content)
print(result.savings_percent)
for step in result.history:
    print(f"{step.stage}: {step.input_tokens} -> {step.output_tokens} tokens")
```

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

### Error Handling with Custom Exceptions

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Implement robust error handling for ScaleDown operations using custom exceptions like AuthenticationError, OptimizerError, and APIError. This ensures graceful failure and informative error messages.

```python
from scaledown import Pipeline
from scaledown.exceptions import (
    AuthenticationError,
    APIError,
    OptimizerError
)

try:
    pipeline = Pipeline([...])
    result = pipeline.run(
        query="find bug",
        file_path="app.py",
        prompt="Analyze"
    )

except AuthenticationError as e:
    print(f"Authentication failed: {e}")

except OptimizerError as e:
    print(f"Optimization failed: {e}")

except APIError as e:
    print(f"API request failed: {e}")

except Exception as e:
    print(f"Unexpected error: {e}")
```

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

### SemanticOptimizer API

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Local embedding-based code search using sentence transformers and FAISS.

```APIDOC
## SemanticOptimizer

### Description
Local embedding-based code search using sentence transformers and FAISS.

### Parameters
- `model_name` (str, default="Qwen/Qwen3-Embedding-0.6B"): HuggingFace embedding model
- `top_k` (int, default=3): Number of top code chunks to retrieve
- `target_model` (str, default="gpt-4o"): Target LLM for token counting

### Methods
- `optimize(context, query, file_path=None, max_tokens=None, **kwargs)`: Find semantically similar code
  - `context` (str): Source code (can be empty if file_path provided)
  - `query` (str, optional): Search query (defaults to "main logic")
  - `file_path` (str, required): Path to Python file to analyze
  - Returns: `OptimizedContext` with `.content` and `.metrics`

### Request Example
```python
optimizer = SemanticOptimizer(
    model_name="Qwen/Qwen3-Embedding-0.6B",
    top_k=5
)
result = optimizer.optimize(
    context="",
    query="authentication middleware",
    file_path="auth.py"
)
```
```

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

### Optimize code with SemanticOptimizer

Source: https://github.com/scaledown-team/scaledown/blob/main/README.md

Finds relevant code snippets using local embedding-based search.

```python
from scaledown.optimizer import SemanticOptimizer

optimizer = SemanticOptimizer(top_k=3)

result = optimizer.optimize(
    context="",
    query="data preprocessing logic",
    file_path="pipeline.py"
)

print(result.content)
```

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

### Handle ScaleDown Exceptions

Source: https://context7.com/scaledown-team/scaledown/llms.txt

Implement robust error handling for ScaleDown operations using custom exception types like ScaleDownError, AuthenticationError, APIError, and OptimizerError.

```python
from scaledown import Pipeline, ScaleDownCompressor
from scaledown.exceptions import (
    ScaleDownError,        # Base exception
    AuthenticationError,   # Missing or invalid API key
    APIError,              # API request failure
    OptimizerError         # Optimizer execution failure
)

try:
    compressor = ScaleDownCompressor(target_model="gpt-4o")
    result = compressor.compress(
        context="Some context",
        prompt="Process this"
    )
except AuthenticationError as e:
    print(f"Authentication failed: {e}")
    print("Set API key with: scaledown.set_api_key('your-key')")

except APIError as e:
    print(f"API request failed: {e}")
    print("Check network connection or API status")

except OptimizerError as e:
    print(f"Optimization failed: {e}")
    print("Ensure required dependencies are installed")

except ScaleDownError as e:
    print(f"ScaleDown error: {e}")

# Optimizer-specific error handling
try:
    optimizer = HasteOptimizer(top_k=5)
    result = optimizer.optimize(
        context="",
        query="find bugs",
        file_path="nonexistent.py"
    )
except OptimizerError as e:
    print(f"HASTE optimization failed: {e}")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.