Pipelex

https://docs.pipelex.com
Admin
Pipelex is an open-source language and framework for building and running repeatable AI workflows by...
Tokens:170,166
Snippets:2,438
Trust Score:5.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install and Initialize Pipelex

Source: https://docs.pipelex.com/latest/get-started/mthds-language-tutorial

Installs the Pipelex tool, initializes a new project, and logs in to the Pipelex Gateway for AI access. Ensure you have the necessary permissions and environment setup.

```bash
uv tool install pipelex
pipelex init
pipelex login

```

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

### Install Dependencies

Source: https://docs.pipelex.com/latest/contributing

Run `make install` to set up the virtual environment and install project dependencies.

```bash
make install
```

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

### Run an installed method

Source: https://docs.pipelex.com/latest/tools/cli/run

Execute a pipeline method by its installed name. This is the basic command to start a pipeline.

```bash
pipelex run method invoice_extractor
```

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

### Clone Cookbook and Install Dependencies

Source: https://docs.pipelex.com/latest/cookbook/hello-world

Clones the Pipelex cookbook repository and installs the necessary Python dependencies. This is the first step to set up the environment for running the example.

```bash
git clone https://github.com/Pipelex/pipelex-cookbook.git
cd pipelex-cookbook
pip install .

```

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

### Copy Example .env File

Source: https://docs.pipelex.com/latest/configuration/config-technical/inference-backend-config

Copy the example .env file to start configuring your provider API keys. Pipelex automatically loads variables from .env files.

```bash
cp .env.example .env
```

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

### Run Discord Newsletter Example

Source: https://docs.pipelex.com/latest/cookbook/discord-newsletter

Executes the Discord newsletter example using a custom Python runner. This command navigates to the example directory and starts the script.

```bash
cd examples/wip/discord_newsletter
python run_discord_newsletter.py


```

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

### PipeParallel Configuration Example

Source: https://docs.pipelex.com/latest/building-methods/pipes/pipe-controllers/PipeParallel

This example demonstrates how to configure a PipeParallel pipe to extract features and analyze sentiment from a product description concurrently. It shows the setup for individual pipes and their parallel execution within PipeParallel, including how to manage combined and individual outputs.

```toml
[concept.ProductAnalysis]
structure = "ProductAnalysis" # A Pydantic model with 'features' and 'sentiment' fields

[pipe.extract_features]
type = "PipeLLM"
description = "Extract features from text"
inputs = { description = "ProductDescription" }
output = "ProductFeatures"

[pipe.analyze_sentiment]
type = "PipeLLM"
description = "Analyze sentiment of text"
inputs = { description = "ProductDescription" }
output = "ProductSentiment"

# The PipeParallel definition
[pipe.analyze_product_in_parallel]
type = "PipeParallel"
description = "Extract features and sentiment at the same time"
inputs = { description = "ProductDescription" }
output = "ProductAnalysis" # This name is for the combined output
add_each_output = true
combined_output = "ProductAnalysis"
branches = [
    { pipe = "extract_features", result = "features" },
    { pipe = "analyze_sentiment", result = "sentiment" },
]

```

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

### Example Pipelex Feature Configuration

Source: https://docs.pipelex.com/latest/configuration/config-advanced/feature-config

An example configuration file snippet showing how to enable the reporting feature for cost monitoring.

```ini
[pipelex.feature_config]
# Enable reporting for cost monitoring
is_reporting_enabled = true

```

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

### Full Logging Configuration Example

Source: https://docs.pipelex.com/latest/configuration/config-practical/logging-config

An example demonstrating a comprehensive logging configuration, including general settings, package-specific levels, and rich console settings. Use this as a template for your own configurations.

```toml
[pipelex.log_config]
default_log_level = "INFO"
log_mode = "rich"
is_console_logging_enabled = true
json_logs_indent = 4
presentation_line_width = 120
is_caller_info_enabled = true
caller_info_template = "file_line_func"

silenced_problem_ids = []
generic_poor_logger = "#poor-log"
poor_loggers = []

[pipelex.log_config.package_log_levels]
pipelex = "INFO"
openai = "WARNING"
anthropic = "INFO"

[pipelex.log_config.rich_log_config]
is_show_time = false
is_show_level = true
is_link_path_enabled = true
highlighter_name = "json"
is_markup_enabled = false
is_rich_tracebacks = true
is_tracebacks_word_wrap = true
is_tracebacks_show_locals = false
tracebacks_suppress = []
keywords_to_hilight = ["error", "warning", "failed"]

```

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

### Running the Expense Validation Example

Source: https://docs.pipelex.com/latest/cookbook/validate-expense-data

Provides instructions on how to execute the expense validation example using a custom Python runner. This involves navigating to the example directory and running a specific Python script.

```bash
cd examples/wip/validate_expense_data
python run_validate_expenses.py

```

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

### Initialize Global Config

Source: https://docs.pipelex.com/latest/tools/cli/init

Recommended for first-time setup to initialize the global configuration directory.

```bash
pipelex init
```

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

### Example .env File Content

Source: https://docs.pipelex.com/latest/configuration/config-technical/inference-backend-config

This is an example of the .env file content, showing available providers and their corresponding API key variables. Uncomment and fill in your keys.

```dotenv
# [OPTIONAL] Free Pipelex Gateway API key - Get yours on Discord: https://go.pipelex.com/discord
PIPELEX_GATEWAY_API_KEY=

OPENAI_API_KEY=

# Amazon Bedrock - For accessing models via Amazon Bedrock
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_REGION=

ANTHROPIC_API_KEY=
MISTRAL_API_KEY=

# Google AI Studio - Use GOOGLE_API_KEY for direct API access (simpler, rate-limited)
GOOGLE_API_KEY=

# Google Cloud Platform (GCP) - Use these for production Vertex AI access
# Choose GOOGLE_API_KEY OR GCP credentials, not both
GCP_PROJECT_ID=
GCP_LOCATION=
GCP_CREDENTIALS_FILE_PATH=gcp_credentials.json

FAL_API_KEY=

LINKUP_API_KEY=
# ... (see .env.example for full list)

```

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

### Example Reporting Configuration

Source: https://docs.pipelex.com/latest/configuration/config-practical/reporting-config

A comprehensive example demonstrating how to configure various reporting settings, including console logging, file generation, custom directory, file naming, and cost unit scaling.

```toml
[pipelex.reporting_config]
# Enable console logging for development
is_log_costs_to_console = true

# Generate report files
is_generate_cost_report_file_enabled = false

# Store reports in a custom directory
cost_report_dir_path = "analytics/cost_reports"

# Customize report file naming
cost_report_base_name = "llm_costs"
cost_report_extension = "csv"

# Show costs in thousands
cost_report_unit_scale = 1000.0

```

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

### Run Inference Plugin Example

Source: https://docs.pipelex.com/latest/cookbook/using-inference-plugins

Execute the example by running the specified pipelex command. Ensure the LLM plugin is configured in your project's `.pipelex/pipelex.toml`.

```bash
pipelex run bundle examples/c_advanced/using_inference_plugins/hello_plugin.mthds

```

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

### Install plxt

Source: https://docs.pipelex.com/latest/tools/plxt

Install plxt as a Pipelex development dependency. Verify installation by checking the help command.

```bash
make install

```

```bash
.venv/bin/plxt --help

```

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

### Manage Runtime Dependencies

Source: https://docs.pipelex.com/latest/contributing

Use `uv pip install <package>` to install runtime dependencies.

```bash
uv pip install <package>
```

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

### PipeSequence Configuration Example

Source: https://docs.pipelex.com/latest/building-methods/pipes/pipe-controllers/PipeSequence

This example demonstrates how to configure a PipeSequence to extract text from an image, summarize it, and then translate the summary to French. It shows the definition of individual pipes and how they are chained together within the PipeSequence.

```toml
[pipe.extract_text_from_image]
type = "PipeExtract"
description = "Extract text from an image"
output = "Text"
model = "mistral-ocr"

[pipe.summarize_text]
type = "PipeLLM"
description = "Summarize text"
inputs = { text = "Text" }
output = "Text"

[pipe.translate_to_french]
type = "PipeLLM"
description = "Translate text to French"
inputs = { text = "Text" }
output = "Text"


[pipe.image_to_french_summary]
type = "PipeSequence"
description = "Extract, summarize, and translate text from an image"
inputs = { image = "source.Image" }
output = "target.FrenchText"
steps = [
    { pipe = "extract_text_from_image", result = "extracted_text" },
    { pipe = "summarize_text", result = "english_summary" },
    { pipe = "translate_to_french", result = "french_summary" },
]


```

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

### Enable Inference Manager Auto Setup

Source: https://docs.pipelex.com/latest/configuration/config-technical/cogt-config

Controls automatic setup for LLM, image generation, and extraction presets.

```ini
[cogt.inference_manager_config]
is_auto_setup_preset_llm = true
is_auto_setup_preset_img_gen = true
is_auto_setup_preset_extract = true

```

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

### Run Design Slides Example

Source: https://docs.pipelex.com/latest/cookbook/design-slides

Command to execute the design slides example using the pipelex CLI. Specify the method file and input JSON.

```bash
pipelex run bundle examples/b_basics/generate_visuals/design_slides/bundle.mthds \
  -i examples/b_basics/generate_visuals/design_slides/inputs.json


```

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

### Initialize Only Configuration Files

Source: https://docs.pipelex.com/latest/tools/cli/init

Use this command to initialize only the configuration files, excluding other setup steps.

```bash
pipelex init config
```

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

### Setup Temporal Namespace

Source: https://docs.pipelex.com/latest/distributed-execution/temporal

Command to register custom search attributes with the Temporal namespace. This is a one-time setup assuming Temporal is reachable.

```bash
pipelex setup-temporal-namespace

```

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

### Example .env File for AWS Credentials

Source: https://docs.pipelex.com/latest/configuration/config-technical/aws-config

Provides an example of how to set AWS credentials and region using environment variables. Ensure these variables are accessible to Pipelex.

```dotenv
AWS_ACCESS_KEY_ID=your_access_key_id
AWS_SECRET_ACCESS_KEY=your_secret_access_key
AWS_REGION=us-east-1


```

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

### Initialize Pipelex and Setup Custom Observer

Source: https://docs.pipelex.com/latest/advanced/observer-provider-injection

Integrate custom observers by initializing Pipelex and then setting your observer instance. This setup allows for automatic observer registration within the Pipelex hub.

```python
from pipelex import Pipelex
from my_project.observers import MyCustomObserver

def setup_pipelex():
    # Initialize Pipelex
    pipelex_instance = Pipelex.make()

    # Setup custom observer
    observer = MyCustomObserver()
    get_pipelex_hub().set_observer(observer)

    return pipelex_instance

```

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

### Example Project Layout

Source: https://docs.pipelex.com/latest/building-methods/packages

Illustrates the typical directory structure for a Pipelex project, including the placement of METHODS.toml.

```plaintext
your-project/
├── METHODS.toml
├── my_project/
│   ├── finance/
│   │   ├── invoices.mthds
│   │   └── invoices_struct.py
│   └── legal/
│       ├── contracts.mthds
│       └── contracts_struct.py
├── .pipelex/
│   └── pipelex.toml
└── requirements.txt

```

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

### Manage Development Dependencies

Source: https://docs.pipelex.com/latest/contributing

Use `uv pip install --extra dev <package>` to install development dependencies.

```bash
uv pip install --extra dev <package>
```

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

### Pipelex Activity Summary Examples

Source: https://docs.pipelex.com/latest/distributed-execution/observability

Examples of semantic meaning captured in the per-activity `summary` field for enhanced observability.

```text
LLM text · pipe=translate_doc · model=openai-gpt-4o
LLM object · pipe=invoice_extractor · class=Invoice
LLM object list · pipe=extract_line_items · class=LineItem
Img gen N× · pipe=cover · model=fal-flux-dev · n=3
Render page views · pipe=extract_doc
Extract pages · pipe=extract_doc · handle=azure-document-intelligence-extract
Templated text · pipe=summary
```

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

### Python Format Output Example

Source: https://docs.pipelex.com/latest/tools/cli/build/output

Demonstrates the Python format output, which generates class instantiation code for custom concepts.

```json
{
  "concept": "my_domain.MyOutputConcept",
  "content": "MyOutputConcept(title=\"title_value\", key_points=\"key_points_value\")"
}
```

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

### Flat Organization Example

Source: https://docs.pipelex.com/latest/configuration/config-technical/library-config

Presents a flat project structure suitable for smaller projects using Pipelex.

```treeview
your_project/
├── my_project/
│   ├── invoice_processing.mthds
│   ├── invoice_struct.py
│   └── main.py
└── .pipelex/

```

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

### Domain-Driven Organization Example

Source: https://docs.pipelex.com/latest/configuration/config-technical/library-config

Demonstrates a domain-driven project structure for organizing Pipelex pipelines and Python structure classes.

```treeview
your_project/
├── my_project/
│   ├── finance/
│   │   ├── pipelines/
│   │   │   └── invoices.mthds
│   │   └── invoice_struct.py
│   ├── legal/
│   │   ├── pipelines/
│   │   │   └── contracts.mthds
│   │   └── contract_struct.py
│   └── main.py
└── .pipelex/

```

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

### Example Dry Run Configuration

Source: https://docs.pipelex.com/latest/configuration/config-pipeline-validation/dry-run-config

An example TOML configuration for Pipelex's dry run settings, demonstrating how to set values for text generation, list items, page extraction, image URLs, and optional failing pipes.

```toml
[pipelex.dry_run_config]
text_gen_truncate_length = 100
nb_list_items = 3
nb_extract_pages = 2
image_urls = ["https://pipelex-pytest-assets.s3.eu-west-3.amazonaws.com/ai_lympics.jpg", "https://pipelex-pytest-assets.s3.eu-west-3.amazonaws.com/animal_lympics.jpg"]
allowed_to_fail_pipes = ["optional_pipe", "experimental_pipe"]

```

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

### Build Output from an Installed Method

Source: https://docs.pipelex.com/latest/tools/cli/build/output

Generate output representation for an installed method by its name. This command can override the method's main pipe and allows specifying library directories.

```bash
pipelex build output method <NAME> [OPTIONS]

```

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

### Tracing Flow Example

Source: https://docs.pipelex.com/latest/under-the-hood/execution-graph-tracing

Illustrates the step-by-step process of tracing a pipeline run, from opening a tracer to closing it and returning the GraphSpec.

```python
# 1. Manager opens tracer for pipeline run
manager = GraphTracerManager.get_or_create_instance()
trace_context = manager.open_tracer(
    graph_id=pipeline_run_id,
    data_inclusion=config.data_inclusion,
    pipeline_ref_domain="my_domain",
    pipeline_ref_main_pipe="my_pipe",
)

# 2. Context flows through JobMetadata to each pipe
job_metadata = JobMetadata(
    pipeline_run_id=pipeline_run_id,
    trace_context=trace_context,
)

# 3. Each pipe reports start/end to tracer
node_id, child_context = manager.on_pipe_start(
    trace_context=trace_context,
    pipe_code="extract_text",
    pipe_type="PipeExtract",
    node_kind=NodeKind.OPERATOR,
    started_at=datetime.now(timezone.utc),
    input_specs=[...],
)

# 4. On completion, report success with output
manager.on_pipe_end_success(
    graph_id=trace_context.graph_id,
    node_id=node_id,
    ended_at=datetime.now(timezone.utc),
    output_spec=IOSpec(...),
)

# 5. Manager closes tracer and returns GraphSpec
graph_spec = manager.close_tracer(pipeline_run_id)

```

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

### Run Hello World Example

Source: https://docs.pipelex.com/latest/cookbook/hello-world

Executes the 'hello_world.mthds' method bundle using the Pipelex CLI. Ensure your environment variables are set up before running this command.

```bash
pipelex run bundle examples/a_quick_start/hello_world.mthds

```

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

### Image Numbering Example in Prompt Comparison

Source: https://docs.pipelex.com/latest/under-the-hood/image-handling-in-llm-prompts

Demonstrates how images are numbered sequentially across system and user prompts. The reference image gets `[Image 1]` and the subject image gets `[Image 2]`.

```toml
[pipe.compare_styles]
inputs = { reference = "Image", subject = "Image" }
system_prompt = "Use this reference image for style comparison: $reference"
prompt = "Analyze the style of this image: $subject"


```

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

### Complete Configuration Example

Source: https://docs.pipelex.com/latest/configuration/config-technical/cogt-config

A comprehensive TOML configuration file demonstrating settings for various cognitive tools including transport, inference manager, LLM, image generation, and OCR.

```toml
[cogt]
transport_max_retries = 2

[cogt.inference_manager_config]
is_auto_setup_preset_llm = true
is_auto_setup_preset_img_gen = true
is_auto_setup_preset_extract = true

[cogt.llm_config]
default_max_images = 100
is_structure_prompt_enabled = false
schema_reask_max_attempts = 3

[cogt.img_gen_config.img_gen_job_config]
is_sync_mode = false

[cogt.img_gen_config.img_gen_param_defaults]
aspect_ratio = "square"
background = "auto"
quality = "low"
# nb_steps = 1
guidance_scale = 3.5
is_moderated = true
safety_tolerance = 5
is_raw = false
output_format = "jpeg"
seed = "auto"

[cogt.extract_config]
default_page_views_dpi = 72

```

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

### Initialize a Package Manifest

Source: https://docs.pipelex.com/latest/building-methods/packages

Command to create a new METHODS.toml file interactively.

```bash
mthds package init

```

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

### Invalid Hierarchical Domains

Source: https://docs.pipelex.com/latest/building-methods/domain

Examples of invalid domain formats. Domains cannot start or end with a dot, have consecutive dots, or use segments that are not snake_case.

```toml
❌ domain = ".legal"              # Cannot start with a dot
❌ domain = "legal."              # Cannot end with a dot
❌ domain = "legal..contracts"    # No consecutive dots
❌ domain = "Legal.Contracts"     # Segments must be snake_case

```

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

### Initialize Project-Local Config

Source: https://docs.pipelex.com/latest/tools/cli/init

Use this command to create a project-level configuration directory.

```bash
pipelex init --local
```

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

### Pipelex Gateway API Key Configuration

Source: https://docs.pipelex.com/latest/get-started/configure-ai-providers

Set up your Pipelex Gateway API key in a .env file. This is the easiest way to get started with LLMs.

```bash
PIPELEX_GATEWAY_API_KEY=your-key-here

```

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

### Implement MetricsObserver

Source: https://docs.pipelex.com/latest/advanced/observer-provider-injection

Develop a custom observer to track pipeline execution metrics. This example increments counters for started, successful, and failed pipeline jobs.

```python
class MetricsObserver(ObserverProtocol):
    def __init__(self, metrics_client):
        self.metrics = metrics_client

    async def before_run(self, payload: PayloadType) -> None:
        pipe_job = payload["pipe_job"]
        self.metrics.increment(f"pipe.{pipe_job.pipe_code}.started")

    async def successful_run(self, payload: PayloadType) -> None:
        pipe_job = payload["pipe_job"]
        self.metrics.increment(f"pipe.{pipe_job.pipe_code}.success")

    async def failing_run(self, payload: PayloadType) -> None:
        pipe_job = payload["pipe_job"]
        self.metrics.increment(f"pipe.{pipe_job.pipe_code}.failed")
```

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

### Image Registry Deduplication Example

Source: https://docs.pipelex.com/latest/under-the-hood/image-handling-in-llm-prompts

Demonstrates how the `ImageRegistry` assigns numbers. The same image URL receives the same number upon subsequent registrations, while a new URL gets a new sequential number.

```python
# First registration
registry.register_image(img_a)  # Returns 1

# Second registration of same URL
registry.register_image(img_a)  # Returns 1 (not 2)

# Different image
registry.register_image(img_b)  # Returns 2
```

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

### Initialize Package Manifest

Source: https://docs.pipelex.com/latest/tools/cli/pkg

Creates a new METHODS.toml manifest file interactively. Use this command to set up the basic metadata for a new package. It prompts for essential details like address, version, and description.

```bash
mthds package init

```

```bash
mthds package init -C ./my-package

```

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

### Build Runner from Installed Method

Source: https://docs.pipelex.com/latest/tools/cli/build/runner

Generates a Python runner script from an installed Pipelex method. Use this to create an executable script for a pipe associated with an installed method.

```bash
pipelex build runner method <NAME> [OPTIONS]
```

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

### Install mthds CLI

Source: https://docs.pipelex.com/latest/get-started/build-with-claude-code

Install the mthds command-line interface globally using npm.

```bash
npm install -g mthds

```

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

### Set up Environment Variables for Pipelex Gateway

Source: https://docs.pipelex.com/latest/configuration/config-technical/inference-backend-config

Copy the example environment file and edit it to include your Pipelex Gateway API key. This is a required step before initializing the gateway.

```bash
# Copy the example environment file
cp .env.example .env

# Edit .env and add your Pipelex Gateway API key
PIPELEX_GATEWAY_API_KEY="your-api-key"

```

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

### Use Field Examples for Enum-like Values

Source: https://docs.pipelex.com/latest/under-the-hood/dry-run-mock-generation

Configure fields to pick from a set of valid values using the `examples` parameter in Pydantic `Field`. When `__use_examples__: True` is set in Polyfactory, it will randomly select from these examples.

```python
class ConceptSpec(StructuredContent):
    # Refines should be one of the native concepts
    refines: str | None = Field(
        default=None,
        examples=["Text", "Image", "Document", "TextAndImages", "Number", "Page"],
    )

class PipeSpec(StructuredContent):
    # Extract talent should be a valid ExtractTalent value
    extract_talent: ExtractTalent | str = Field(
        description="Select extraction model talent",
        examples=list(ExtractTalent),  # Polyfactory picks randomly from these
    )

```

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

### Cross-Package Reference Example

Source: https://docs.pipelex.com/latest/building-methods/packages

An example of a pipe definition that references a pipe from another package using an alias.

```toml
[pipe.analyze_item]
type = "PipeSequence"
description = "Analyze an item using another package"
steps = [
    { pipe = "scoring_lib->scoring.compute_weighted_score" },
]

```

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

### Initialize Pipelex and Accept Terms

Source: https://docs.pipelex.com/latest/configuration/config-technical/inference-backend-config

Run the pipelex init command to accept the Gateway terms of service and verify the configuration. This command will prompt you to review and accept the terms.

```bash
pipelex init

```

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

### Agent Initialize with OpenAI Backend

Source: https://docs.pipelex.com/latest/tools/cli/init

Initialize the agent with the OpenAI backend and anonymous telemetry, using project-level configuration.

```bash
pipelex-agent init --config '{"backends": ["openai"], "telemetry_mode": "off"}'
```

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

### Install MTHDS Plugin Marketplace

Source: https://docs.pipelex.com/latest/features/claude-code-skills-plugin

Add the MTHDS plugin to your Claude Code marketplace. This is the first step to installing the plugin.

```bash
/plugin marketplace add mthds-ai/mthds-plugins

```

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

### Initialize Pipelex Configuration

Source: https://docs.pipelex.com/latest/tools/cli/init

Use `pipelex init` to set up global configuration files. Use `--local` to create a project-level configuration. This command performs a full reset of configuration files.

```bash
pipelex init [FOCUS]
pipelex init --local [FOCUS]
```

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

### Define Hello World Method

Source: https://docs.pipelex.com/latest/cookbook/hello-world

Defines a simple Pipelex method bundle that uses a PipeLLM operator to generate a haiku about 'Hello World'. This serves as the core logic for the example.

```toml
domain    = "quick_start"
main_pipe = "hello_world"

[pipe]
[pipe.hello_world]
type = "PipeLLM"
description = "Write text about Hello World."
output = "Text"
prompt = """
Write a haiku about Hello World.
"""

```

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

### Install MTHDS Plugin

Source: https://docs.pipelex.com/latest/features/claude-code-skills-plugin

Install the MTHDS plugin after adding it to the marketplace. This makes the plugin's commands available in Claude Code.

```bash
/plugin install mthds@mthds-plugins

```

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

### Example Concept Definition (.mthds)

Source: https://docs.pipelex.com/latest/tools/cli/build/structures

This is an example of a concept definition in the .mthds format, illustrating how to define a candidate profile with various fields.

```ini
[concept.CandidateProfile]
description = "A structured representation of a candidate's professional background."

[concept.CandidateProfile.structure]
skills = { type = "text", description = "Technical and soft skills", required = true }
years_of_experience = { type = "number", description = "Total years of experience" }
education = { type = "text", description = "Educational background", required = true }
work_history = { type = "text", description = "Summary of previous roles", required = true }

```

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

### Model List Syntax Examples

Source: https://docs.pipelex.com/latest/under-the-hood/test-profile-configuration

Demonstrates various ways to define lists of language models using different syntaxes, including collections, glob patterns, and exclusions.

```toml
# Use all Anthropic models from the collection
llm_models = ["@anthropic"]

# Use all Claude 4.5 models (glob pattern)
llm_models = ["claude-4.5-*"]

# Use all GPT models except codex variants
llm_models = ["gpt-*", "!*-codex", "!*-codex-*"]

# Combine collection reference with specific models
llm_models = ["@anthropic", "gpt-4o-mini", "gemini-2.5-flash"]

# Use all models from the openai backend
llm_models = ["openai:*"]

# Use all backends
backends = ["@all"]

```

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

### Define a Multi-Step Method with PipeSequence

Source: https://docs.pipelex.com/latest/building-methods/pipes

This example demonstrates defining a marketing domain with concepts and a two-step pipe sequence. The first pipe generates a tagline from a product description, and the second extracts keywords from the generated tagline. Use PipeSequence to orchestrate these steps.

```plaintext
domain = "marketing"
description = "Marketing content generation domain"

# 1. Define the concepts used in our pipes
[concept]
ProductDescription = "A description of a product's features and benefits"
Tagline = "A catchy marketing tagline"

# 2. Define the first step of your pipe
[pipe.generate_tagline]
type = "PipeLLM"
description = "Generate a catchy tagline for a product"
inputs = { description = "ProductDescription" }
output = "Tagline"
prompt = """
Product Description:
@description

Generate a catchy tagline based on the above description.
The tagline should be memorable, concise, and highlight the key benefit.
"""

# 3. Define the second step of your pipe
[pipe.extract_keywords_from_tagline]
type = "PipeLLM"
description = "Extract keywords from a tagline"
inputs = { tagline = "Tagline" }
output = "Keyword[]"
prompt = """
Extract the most relevant keywords from the following tagline. Focus on features, benefits, and unique selling points:

@tagline

"""

# 4. Define the controller that orchestrates the two steps
[pipe.description_to_tagline]
type = "PipeSequence"
description = "From product description to tagline"
inputs = { description = "ProductDescription" }
output = "Tagline"
steps = [
    { pipe = "generate_tagline", result = "tagline" },
    { pipe = "extract_keywords_from_tagline", result = "keywords" },
]

```

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

### Example CSV Data

Source: https://docs.pipelex.com/latest/building-methods/pipes/csv-input-and-output

This is an example of a CSV file with a header row and data. Pipelex uses the header to map columns to concept fields.

```csv
name,job,country,birth_year,death_year
Ada Lovelace,Mathematician,United Kingdom,1815,1852
Grace Hopper,Computer Scientist,United States,1906,1992
Vint Cerf,Computer Scientist,United States,1943,

```

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

### Pipe Definition Example

Source: https://docs.pipelex.com/latest/building-methods/pipelex-bundle-specification

An example of a pipe definition, specifying its type, description, inputs, and output. Pipes are the processing units within a Pipelex bundle.

```toml
[pipe.extract_invoice]
type = "PipeExtract"
description = "Extract text and images from an invoice PDF"
inputs = { document = "Document" }
output = "Page"

```

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

### Invalid Domain Code Examples

Source: https://docs.pipelex.com/latest/building-methods/domain

Examples of invalid domain codes that violate the snake_case naming convention. These include uppercase letters, hyphens, and camelCase.

```MTHDS
# No uppercase
domain = "Finance"
```

```MTHDS
# No hyphens
domain = "invoice-processing"
```

```MTHDS
# No all caps
domain = "INVOICE_PROCESSING"
```

```MTHDS
# camelCase not allowed
domain = "invoiceProcessing"
```

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

### Example Generated Python Class

Source: https://docs.pipelex.com/latest/building-methods/concepts/inline-structures

This is an example of a Python class generated by Pipelex from an inline structure definition, including type hints and Pydantic Field definitions.

```python
# generated/finance__invoice.py
from pydantic import Field
from pipelex.core.stuffs.structured_content import StructuredContent
from .finance__customer import Customer
from .finance__line_item import LineItem

class Invoice(StructuredContent):
    """A commercial document issued by a buyer"""

    invoice_number: str = Field(description="The unique invoice identifier")
    issue_date: datetime = Field(..., description="The date the invoice was issued")
    customer: Customer = Field(..., description="The customer for this invoice")
    line_items: list[LineItem] = Field(..., description="List of line items")
    total_amount: float = Field(..., description="The total invoice amount")

```

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

### Valid Domain Code Examples

Source: https://docs.pipelex.com/latest/building-methods/domain

Examples of valid domain codes that adhere to the snake_case naming convention. Domain codes must be lowercase with underscores and descriptive.

```MTHDS
domain = "finance"
```

```MTHDS
domain = "invoice_processing"
```

```MTHDS
domain = "medical_records"
```

```MTHDS
domain = "customer_service"
```

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

### Input JSON Format Example

Source: https://docs.pipelex.com/latest/tools/cli/run

Example of the expected JSON format for providing input variables to the pipeline execution tool. Keys represent input variable names.

```json
{
  "input_variable": "simple string value",
  "another_input": {
    "concept": "domain_code.ConceptName",
    "content": { "field": "value" }
  }
}
```

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

### Run a Pipe by Code

Source: https://docs.pipelex.com/latest/tools/cli/run

Execute a pipe named 'hello_world' from the project's pipe library.

```bash
pipelex run pipe hello_world
```

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

### Generate Inputs from an Installed Method

Source: https://docs.pipelex.com/latest/tools/cli/build/inputs

Generate input JSON for a pipe based on an installed method's name. The `--pipe` option can override the method's default `main_pipe`.

```bash
pipelex build inputs method <NAME> [OPTIONS]

```

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

### Execute Pipeline by Code (Current Directory)

Source: https://docs.pipelex.com/latest/building-methods/pipes/executing-pipelines

Initializes Pipelex, then executes a pipeline using its code. This example loads pipe definitions from the current working directory.

```python
from pipelex.pipelex import Pipelex
from pipelex.pipeline.runner import PipelexMTHDSProtocol

# First, initialize Pipelex (this loads all pipeline definitions)
Pipelex.make()

# Execute the pipeline and wait for the result
runner = PipelexMTHDSProtocol()
response = await runner.execute(
    pipe_code="description_to_tagline",
    inputs={
        "description": {
            "concept": "ProductDescription",
            "content": "EcoClean Pro is a revolutionary biodegradable cleaning solution that removes 99.9% of germs while being completely safe for children and pets. Made from plant-based ingredients.",
        },
    },
)
pipe_output = response.pipe_output

```

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

### Bundle-Level System Prompt

Source: https://docs.pipelex.com/latest/building-methods/pipelex-bundle-specification

Demonstrates how to define a bundle-level system prompt that applies to all PipeLLM operators within the bundle. Individual pipes can override this.

```toml
domain = "medical_records"
system_prompt = "You are a medical records specialist with expertise in HIPAA compliance and clinical documentation."

[pipe.extract_diagnosis]
type = "PipeLLM"
# This pipe will automatically use the bundle's system_prompt
inputs = { record = "MedicalRecord" }
output = "Diagnosis"
prompt = "Extract the primary diagnosis from this medical record: @record"

```

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

### Running the Advisory Board Example

Source: https://docs.pipelex.com/latest/cookbook/advisory-board

Command to execute the advisory board pipeline using the pipelex CLI. Specify the main method bundle and the input JSON file.

```bash
pipelex run bundle examples/wip/advisory_board/bundle.mthds \
  -i examples/wip/advisory_board/inputs.json


```

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

### Run Pipe with Custom Output Directory

Source: https://docs.pipelex.com/latest/tools/cli/run

Execute a pipe named 'hello_world' and save its outputs to the 'my_output/' directory.

```bash
pipelex run pipe hello_world --output-dir my_output/
```
Tokens:
Raw