Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.
feature/Docs-cookbook-section-one · L-260924-2038a4 (#1258)
Louis Choquelfe37940964fe
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 783581ea1..08000f42b 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -6,6 +6,7 @@- **The pitch names who each way of running a method is for**: the README, the documentation's front page and **Quick Start**, and the site description now say a method runs "as an MCP for chatbots, as a webapp for people, or via API for your software", instead of "from your agent or your chatbot via MCP, as a webapp, or via API in any software".- **The quick start says the plugin also puts a method in your software**: the README and the documentation's **Quick Start** now say the plugin's skills build methods, run them and put them in your software, name `/pipelex-scaffold` for a webapp and `/pipelex-integrate` for a typed call from TypeScript or Python code, and say that `@pipelex/sdk` is the TypeScript SDK and `pipelex-sdk` the Python one.+- **The documentation's cookbook is one page that points to the cookbook**: the cookbook now holds Pipelex's example methods as packages you run by their address on the hosted API, each with its own page showing every way to use it, so the documentation no longer keeps a page per example. **The Pipelex Cookbook** says what the cookbook is and links to it, the pages that linked an example now link its page in the cookbook or in the method library, and every old example address redirects to the new page. The two pages that documented the runtime itself move into the runtime's own sections: **Writing an Inference Plugin**, under **Under the Hood**, now carries the whole sample plugin and the configuration that routes a model to it, and **CV Batch Screening, Step by Step** joins **Get Started**. The README's cookbook line says what the cookbook now is.## [v0.65.0] - 2026-09-25diff --git a/README.md b/README.mdindex bb1fad0ce..a58ab6052 100644--- a/README.md+++ b/README.md@@ -144,7 +144,7 @@ Then run it:pipelex run bundle summarize.mthds --inputs inputs.json```-The result is written under `results/`. For a method with several steps, typed concepts and a batch, run from the CLI and from Python, read [CV batch screening, step by step](https://docs.pipelex.com/latest/cookbook/cv-batch-screening/).+The result is written under `results/`. For a method with several steps, typed concepts and a batch, run from the CLI and from Python, read [CV batch screening, step by step](https://docs.pipelex.com/latest/get-started/cv-batch-screening/).### Editor extension@@ -210,8 +210,8 @@ The same `.mthds` file runs from multiple execution targets:## Documentation- [docs.pipelex.com](https://docs.pipelex.com/): the Pipelex documentation, from the MTHDS language tutorial to the CLI reference.-- [CV batch screening, step by step](https://docs.pipelex.com/latest/cookbook/cv-batch-screening/): a production method with its concepts, its pipes and its flowchart, and how to run it from the CLI and from Python.-- [The cookbook](https://github.com/Pipelex/pipelex-cookbook): methods to clone, run and adapt.+- [CV batch screening, step by step](https://docs.pipelex.com/latest/get-started/cv-batch-screening/): a production method with its concepts, its pipes and its flowchart, and how to run it from the CLI and from Python.+- [The cookbook](https://github.com/Pipelex/pipelex-cookbook): Pipelex's example methods, which run by their address on the hosted API with nothing to install, each with a page showing every way to use it: in your chatbot, in your coding agent, in your code, as an app, or as a method of your own.- [The MTHDS standard](https://mthds.ai/latest/): the language a method is written in.- [The changelog](https://docs.pipelex.com/latest/changelog/).diff --git a/docs/404.html b/docs/404.htmlindex dfa8b81cf..18be74a8e 100644--- a/docs/404.html+++ b/docs/404.html@@ -110,6 +110,30 @@'distributed-execution/workers': 'distributed-execution','distributed-execution/task-routing': 'distributed-execution','distributed-execution/observability': 'distributed-execution',+ 'cookbook/simple-ocr': 'cookbook',+ 'cookbook/invoice-extractor': 'cookbook',+ 'cookbook/advisory-board': 'cookbook',+ 'cookbook/blog-article-generator': 'cookbook',+ 'cookbook/design-slides': 'cookbook',+ 'cookbook/discord-newsletter': 'cookbook',+ 'cookbook/extract-dpe': 'cookbook',+ 'cookbook/extract-gantt': 'cookbook',+ 'cookbook/extract-generic': 'cookbook',+ 'cookbook/extract-invoice': 'cookbook',+ 'cookbook/extract-markdown': 'cookbook',+ 'cookbook/extract-proof-of-purchase': 'cookbook',+ 'cookbook/extract-slides': 'cookbook',+ 'cookbook/extract-table': 'cookbook',+ 'cookbook/gen-expense-data': 'cookbook',+ 'cookbook/gen-synthetic-data': 'cookbook',+ 'cookbook/generate-image': 'cookbook',+ 'cookbook/hello-world': 'cookbook',+ 'cookbook/summarize': 'cookbook',+ 'cookbook/validate-expense-data': 'cookbook',+ 'cookbook/write-screenplay': 'cookbook',+ 'cookbook/write-tweet': 'cookbook',+ 'cookbook/cv-batch-screening': 'get-started/cv-batch-screening',+ 'cookbook/using-inference-plugins': 'under-the-hood/writing-an-inference-plugin',};function rewritePath(p) {diff --git a/docs/building-methods/pipes/pipe-controllers/PipeSequence.md b/docs/building-methods/pipes/pipe-controllers/PipeSequence.mdindex 675a41672..50b9f931a 100644--- a/docs/building-methods/pipes/pipe-controllers/PipeSequence.md+++ b/docs/building-methods/pipes/pipe-controllers/PipeSequence.md@@ -83,7 +83,7 @@ steps = [## Related Documentation-- [Invoice Extraction Example](../../../cookbook/extract-invoice.md) - Complete invoice processing pipeline using PipeSequence-- [Write Tweet Example](../../../cookbook/write-tweet.md) - Multi-step tweet generation workflow-- [Table Extraction Example](../../../cookbook/extract-table.md) - Extract and correct tables from images-- [Gantt Extraction Example](../../../cookbook/extract-gantt.md) - Extract Gantt chart data from documents\ No newline at end of file+- [Invoice extraction](https://github.com/Pipelex/methods/tree/main/methods/invoice_extraction) - A method in the method library that classifies each page, then extracts structured invoice data+- [Tweet optimizer](https://github.com/Pipelex/methods/tree/main/methods/tweet_optimizer) - A method in the method library that scores a draft tweet and rewrites it in your style+- [Table extraction](https://github.com/Pipelex/methods/tree/main/methods/table_extraction) - A method in the method library that extracts a table from a screenshot into HTML, then reviews it against the image+- [Gantt chart extraction](https://github.com/Pipelex/pipelex-cookbook/tree/main/methods/extract_gantt) - A cookbook method that returns every task and milestone of a Gantt chart image with their dates\ No newline at end of filediff --git a/docs/building-methods/pipes/pipe-operators/PipeExtract.md b/docs/building-methods/pipes/pipe-operators/PipeExtract.mdindex d1916bc14..e834cbd10 100644--- a/docs/building-methods/pipes/pipe-operators/PipeExtract.md+++ b/docs/building-methods/pipes/pipe-operators/PipeExtract.md@@ -106,6 +106,6 @@ Pass a web URL as the `article_url` input when running the pipe. PipeExtract fet## Related Documentation-- [Generic Document Extraction Example](../../../cookbook/extract-generic.md) - Extract markdown from complex PDFs using vision-- [Invoice Extraction Example](../../../cookbook/extract-invoice.md) - Complete invoice processing pipeline+- [Generic document extraction](https://github.com/Pipelex/pipelex-cookbook/tree/main/methods/extract_generic) - A cookbook method that returns each page of any document as Markdown, including the text inside its images and diagrams+- [Invoice extraction](https://github.com/Pipelex/methods/tree/main/methods/invoice_extraction) - A method in the method library that extracts structured invoice data using both the OCR text and the page view- [Document Extraction Feature](../../../features/document-extraction.md) - Overview of document extraction capabilitiesdiff --git a/docs/building-methods/pipes/pipe-operators/PipeLLM.md b/docs/building-methods/pipes/pipe-operators/PipeLLM.mdindex 35b26007b..ba238d7c7 100644--- a/docs/building-methods/pipes/pipe-operators/PipeLLM.md+++ b/docs/building-methods/pipes/pipe-operators/PipeLLM.md@@ -430,8 +430,8 @@ Analyze the following topic in depth, considering multiple perspectives:## Related Documentation-- [Hello World Example](../../../cookbook/hello-world.md) - Simple introductory example using PipeLLM-- [Invoice Extraction Example](../../../cookbook/extract-invoice.md) - Complete invoice processing pipeline-- [Write Tweet Example](../../../cookbook/write-tweet.md) - Multi-step tweet generation workflow-- [Table Extraction Example](../../../cookbook/extract-table.md) - Extract and correct tables from images-- [Gantt Extraction Example](../../../cookbook/extract-gantt.md) - Extract Gantt chart data from documents\ No newline at end of file+- [The MTHDS Language Tutorial](../../../get-started/mthds-language-tutorial.md#step-1-hello-world) - Starts from a single PipeLLM and builds a method step by step+- [Invoice extraction](https://github.com/Pipelex/methods/tree/main/methods/invoice_extraction) - A method in the method library that extracts structured invoice data using both the OCR text and the page view+- [Tweet optimizer](https://github.com/Pipelex/methods/tree/main/methods/tweet_optimizer) - A method in the method library that scores a draft tweet and rewrites it in your style+- [Table extraction](https://github.com/Pipelex/methods/tree/main/methods/table_extraction) - A method in the method library that extracts a table from a screenshot into HTML, then reviews it against the image+- [Gantt chart extraction](https://github.com/Pipelex/pipelex-cookbook/tree/main/methods/extract_gantt) - A cookbook method that returns every task and milestone of a Gantt chart image with their dates\ No newline at end of filediff --git a/docs/cookbook/advisory-board.md b/docs/cookbook/advisory-board.mddeleted file mode 100644index f6828e563..000000000--- a/docs/cookbook/advisory-board.md+++ /dev/null@@ -1,64 +0,0 @@-----title: "Advisory Board Example"-description: "Solve complex business problems through multi-board consultation — a Pipelex pipeline that consults specialized advisory boards and synthesizes strategic recommendations."------# Example: Advisory Board--!!! warning "Work in Progress"- This example is under active development and may change.--This example solves complex business problems by consulting multiple specialized advisory boards (Executive, Product, Engineering, Marketing, etc.), analyzing consensus and conflicts across their responses, and producing a comprehensive strategic report.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/wip/advisory_board/bundle.mthds)--## What it demonstrates--- Complex concept hierarchy (BusinessProblem, AdvisoryBoard, BoardResponse, ConsensusItem, ConflictItem, StrategicReport, etc.)-- Multi-board consultation pattern with batching-- Consensus and conflict analysis across expert opinions-- Multi-file method bundle (main `bundle.mthds` + `presentation.mthds`)-- 16 specialized advisory boards to choose from--## The Method: `bundle.mthds`--### Pipeline overview--```toml-[pipe.master_advisory_orchestrator]-type = "PipeSequence"-inputs = { user_input = "Text" }-output = "presentation.MarkdownReport"-steps = [- { pipe = "classify_business_problem", result = "business_problem" },- { pipe = "select_advisory_boards", result = "selected_advisory_boards" },- { pipe = "consult_board", batch_over = "selected_advisory_boards", batch_as = "advisory_board", result = "board_consultations" },- { pipe = "analyze_board_responses", result = "response_analysis" },- { pipe = "generate_strategic_report", result = "strategic_report" },- { pipe = "present_as_markdown", result = "strategic_report_markdown" },-]-```--The pipeline:--1. **Classifies** the business problem into a structured `BusinessProblem` (category, urgency, stakeholders)-2. **Selects** 5-10 relevant advisory boards from 16 available-3. **Consults** each board in parallel (batched) for domain-specific recommendations-4. **Analyzes** all responses to find consensus, conflicts, and unique insights-5. **Generates** a comprehensive strategic report with implementation roadmap and risk assessment-6. **Presents** the report as formatted markdown--## How to run--```bash-pipelex run bundle examples/wip/advisory_board/bundle.mthds \- -i examples/wip/advisory_board/inputs.json-```--## Related Documentation--- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflows-- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Understanding Multiplicity](../building-methods/pipes/understanding-multiplicity.md) - How batching worksdiff --git a/docs/cookbook/blog-article-generator.md b/docs/cookbook/blog-article-generator.mddeleted file mode 100644index 15d1b3d7c..000000000--- a/docs/cookbook/blog-article-generator.md+++ /dev/null@@ -1,66 +0,0 @@-----title: "Blog Article Generator Example"-description: "Generate SEO-optimized blog articles from a structured request using a two-step Pipelex pipeline."------# Example: Blog Article Generator--!!! warning "Work in Progress"- This example is under active development and may change.--This example generates complete SEO-optimized blog articles from a structured request. It uses a two-step pipeline: create an outline, then write the full article.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/wip/blog_article_generator/bundle.mthds)--## What it demonstrates--- Structured input concept (`BlogArticleRequest` with topic, audience, tone, length)-- Two-step content generation: outline then write-- Constrained choices for tone and length fields--## The Method: `bundle.mthds`--### Input concept--```toml-[concept.BlogArticleRequest]-description = "Structured request describing the blog article to generate"--[concept.BlogArticleRequest.structure]-text = { type = "text", description = "Free-form instruction for the article", required = true }-topic = { type = "text", description = "The main topic of the blog article", required = true }-audience = { type = "text", description = "Target audience for the article", required = true }-tone = { type = "text", description = "Writing tone", choices = [- "Casual", "Professional", "Humorous", "Academic",-], required = true }-length = { type = "text", description = "Desired article length", choices = [- "Short", "Medium", "Long",-], required = true }-```--### Pipeline--```toml-[pipe.generate_blog_article]-type = "PipeSequence"-inputs = { user_prompt = "BlogArticleRequest" }-output = "BlogArticle"-steps = [- { pipe = "create_outline", result = "outline" },- { pipe = "write_article", result = "article" },-]-```--## How to run--```bash-pipelex run bundle examples/wip/blog_article_generator/bundle.mthds \- -i examples/wip/blog_article_generator/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/cookbook/design-slides.md b/docs/cookbook/design-slides.mddeleted file mode 100644index 995d0f74c..000000000--- a/docs/cookbook/design-slides.md+++ /dev/null@@ -1,83 +0,0 @@-----title: "Design Slides Example"-description: "Generate multiple slide design proposals from a brief — including themes, visual mockups, and an HTML report — using Pipelex."------# Example: Design Slides--This example takes a slide design brief and generates multiple themed design proposals, complete with visual mockups and an HTML report comparing them.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/generate_visuals/design_slides/bundle.mthds)--## What it demonstrates--- Rich concept hierarchy (nested structures: `Theme` contains `ColorPalette`, `Typography`, `LayoutSettings`, `StyleSettings`)-- `nb_output` parameter to generate multiple results from a single pipe-- `PipeImgGen` for generating visual mockup images-- `PipeCompose` with an HTML template for report rendering-- Multi-step creative pipeline: polish brief, generate themes, render visuals, compose report--## The Method: `bundle.mthds`--### Key concepts--The method defines a deep hierarchy of design concepts:--```toml-[concept.SlideDesignBrief]-description = "Client brief for slide deck design"--[concept.SlideDesignBrief.structure]-topic = { type = "text", description = "The main topic or subject of the presentation", required = true }-brand_guidelines = { type = "text", description = "The client's brand guidelines", required = false }-tone = { type = "text", description = "The tone of the presentation", choices = [- "formal", "playful", "innovative", "trustworthy", "artsy",-], required = false }-# ... goal, audience fields-```--```toml-[concept.Theme]-description = "Complete presentation theme with colors, typography, layout, and style"--[concept.Theme.structure]-name = { type = "text", description = "Theme name identifier", required = true }-colors = { type = "concept", concept_ref = "ColorPalette", description = "Color palette for the theme", required = true }-typography = { type = "concept", concept_ref = "Typography", description = "Typography settings", required = true }-layout = { type = "concept", concept_ref = "LayoutSettings", description = "Layout configuration", required = true }-style = { type = "concept", concept_ref = "StyleSettings", description = "Visual style settings", required = true }-```--### Pipeline--```toml-[pipe.generate_design_proposals_from_rough_brief]-type = "PipeSequence"-description = "Transform a design brief into multiple themes with visual mockups and HTML report"-inputs = { brief = "SlideDesignBrief" }-output = "Html"-steps = [- { pipe = "polish_brief", result = "polished_brief" },- { pipe = "generate_multiple_themes", nb_output = 3, result = "themes" },- { pipe = "render_visual_proposal", batch_over = "themes", batch_as = "theme", result = "design_proposals" },- { pipe = "compose_proposals_report", result = "proposals_report" },-]-```--The `nb_output = 3` parameter tells `generate_multiple_themes` to produce 3 different theme proposals. Each theme is then rendered as a visual mockup using `PipeImgGen`, and everything is assembled into an HTML report.--## How to run--```bash-pipelex run bundle examples/b_basics/generate_visuals/design_slides/bundle.mthds \- -i examples/b_basics/generate_visuals/design_slides/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeImgGen Operator](../building-methods/pipes/pipe-operators/PipeImgGen.md) - Generate images from prompts-- [PipeCompose Operator](../building-methods/pipes/pipe-operators/PipeCompose.md) - Template-based data composition-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/cookbook/discord-newsletter.md b/docs/cookbook/discord-newsletter.mddeleted file mode 100644index 2053d9f46..000000000--- a/docs/cookbook/discord-newsletter.md+++ /dev/null@@ -1,71 +0,0 @@-----title: "Discord Newsletter Example"-description: "Generate HTML newsletters from Discord channel data — summarize messages, organize by category, and format as a weekly digest."------# Example: Discord Newsletter--!!! warning "Work in Progress"- This example is under active development and may change.--This example generates HTML newsletters from Discord channel data. It summarizes messages from each channel, organizes them by category (Share, Introduce Yourself, Geographic Hubs), and formats everything as a weekly newsletter.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/wip/discord_newsletter/bundle.mthds)--## What it demonstrates--- `PipeCondition` for conditional routing based on channel name-- Structured Discord data concepts (messages, attachments, embeds, channels)-- Channel-specific summarization strategies (new members vs. general)-- `PipeCompose` with complex Jinja2 HTML template (filtering, sorting, conditional sections)-- Custom Python runner for loading external JSON data--## The Method: `bundle.mthds`--### Pipeline--```toml-[pipe.write_discord_newsletter]-type = "PipeSequence"-inputs = { discord_channel_updates = "DiscordChannelUpdate[]" }-output = "HtmlNewsletter"-steps = [- { pipe = "summarize_discord_channel_update",- batch_over = "discord_channel_updates", batch_as = "discord_channel_update",- result = "channel_summaries" },- { pipe = "write_weekly_summary", result = "weekly_summary" },- { pipe = "format_html_newsletter", result = "html_newsletter" },-]-```--### Conditional routing--The `summarize_discord_channel_update` pipe uses `PipeCondition` to route different channels to different summarization strategies:--```toml-[pipe.summarize_discord_channel_update]-type = "PipeCondition"-description = "Select the appropriate summary pipe based on the channel name"-inputs = { discord_channel_update = "DiscordChannelUpdate" }-output = "ChannelSummary"-expression = "discord_channel_update.name"-outcomes = { "Introduce-Yourself" = "summarize_discord_channel_update_for_new_members" }-default_outcome = "summarize_discord_channel_update_general"-```--## How to run--This example requires a custom Python runner to load Discord channel data from JSON:--```bash-cd examples/wip/discord_newsletter-python run_discord_newsletter.py-```--## Related Documentation--- [PipeCondition Controller](../building-methods/pipes/pipe-controllers/PipeCondition.md) - Conditional pipe routing-- [PipeCompose Operator](../building-methods/pipes/pipe-operators/PipeCompose.md) - Template-based data composition-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/cookbook/extract-dpe.md b/docs/cookbook/extract-dpe.mddeleted file mode 100644index 32b2d9b6a..000000000--- a/docs/cookbook/extract-dpe.md+++ /dev/null@@ -1,71 +0,0 @@-----title: "DPE Extraction Example"-description: "Extract structured data from French energy performance diagnostics (DPE) using vision-based Pipelex pipelines and typed schemas."------# Example: DPE Extraction--This example extracts information from French "Diagnostic de Performance Energetique" (DPE) documents. It uses a three-step pipeline: extract pages, convert each to markdown using vision, then conclude the DPE details from the combined markdown.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_dpe/bundle.mthds)--## What it demonstrates--- Custom structured concept with constrained choices (energy efficiency classes A-G)-- Three-step extraction: pages, markdown per page, then conclude-- Vision-based extraction focused on specific document elements (energy classes, graphs, tables)-- Using shared method packages for page extraction--## The Method: `bundle.mthds`--### DPE concept--```toml-[concept.Dpe]-description = "A diagnostic of the energy performance of a building"--[concept.Dpe.structure]-address = { type = "text", description = "The address of the building" }-date_of_issue = { type = "date", description = "The date the DPE was issued" }-date_of_expiration = { type = "date", description = "The expiration date of the DPE" }-energy_efficiency_class = { type = "text", description = "The energy efficiency class",- choices = ["A", "B", "C", "D", "E", "F", "G"] }-per_year_per_m2_consumption = { type = "number", description = "Energy consumption per year per m2" }-co2_emission_class = { type = "text", description = "The CO2 emission class",- choices = ["A", "B", "C", "D", "E", "F", "G"] }-per_year_per_m2_co2_emissions = { type = "number", description = "CO2 emissions per year per m2" }-yearly_energy_costs = { type = "number", description = "Yearly energy costs" }-```--### Pipeline--```toml-[pipe.power_extractor_dpe]-type = "PipeSequence"-inputs = { document = "Document" }-output = "Dpe"-steps = [- { pipe = "github.com/Pipelex/methods/documents->documents.extract_page_contents_and_views",- result = "page_contents" },- { pipe = "write_markdown_from_page_content_dpe",- batch_over = "page_contents", batch_as = "page_content",- result = "dpe_pages" },- { pipe = "conclude_dpe", result = "dpe" },-]-```--The final `conclude_dpe` step takes all the markdown pages and produces a single structured `Dpe` object.--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_dpe/bundle.mthds \- -i examples/b_basics/document_extract/extract_dpe/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Document Extraction](../features/document-extraction.md) - Overview of document extraction capabilitiesdiff --git a/docs/cookbook/extract-gantt.md b/docs/cookbook/extract-gantt.mddeleted file mode 100644index 8195bbd34..000000000--- a/docs/cookbook/extract-gantt.md+++ /dev/null@@ -1,55 +0,0 @@-----title: "Gantt Chart Extraction Example"-description: "Extract tasks, dates, and dependencies from Gantt chart images using a step-by-step divide-and-conquer Pipelex pipeline."------# Example: Gantt Chart Extraction--This example extracts structured information from Gantt chart images: timescale, task names, task details (dates, dependencies), and milestones. It uses a "divide and conquer" approach where each aspect is extracted separately.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_gantt/bundle.mthds)--## What it demonstrates--- Divide-and-conquer extraction: timescale, task names, task details, then assemble-- Batching over task names to extract details for each independently-- Vision-based extraction using `$vision-diagram` model-- Rich structured output (`GanttChart` with `GanttTaskDetails` and `Milestone` lists)-- Two alternative approaches: step-by-step vs. direct one-shot extraction--## The Method: `bundle.mthds`--### Pipeline--```toml-[pipe.extract_gantt_by_steps]-type = "PipeSequence"-description = "Extract all details from a gantt chart"-inputs = { gantt_chart_image = "GanttChartImage" }-output = "GanttChart"-steps = [- { pipe = "extract_gantt_timescale", result = "gantt_timescale" },- { pipe = "extract_gantt_task_names", result = "gantt_task_names" },- { pipe = "extract_details_of_task", batch_as = "gantt_task_name",- result = "details_of_all_tasks" },- { pipe = "gather_in_a_gantt_chart", result = "gantt_chart" },-]-```--Each task's details are extracted individually using the chart image, the timescale context, and the specific task name — making each extraction focused and accurate.--The bundle also includes a `transcript_gantt_direct` pipe for one-shot extraction to markdown, useful for simpler charts.--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_gantt/bundle.mthds \- -i examples/b_basics/document_extract/extract_gantt/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/cookbook/extract-generic.md b/docs/cookbook/extract-generic.mddeleted file mode 100644index 7408b0a50..000000000--- a/docs/cookbook/extract-generic.md+++ /dev/null@@ -1,71 +0,0 @@-----title: "Generic Document Extraction Example"-description: "Extract content from complex PDF documents containing text and images. This Pipelex pipeline converts each page to markdown using vision."------# Example: Generic Document Extraction--This example demonstrates a generic pipeline for extracting content from complex PDF documents. It extracts pages with views, then converts each page to markdown using a vision-capable LLM that combines OCR text with the page image.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_generic/bundle.mthds)--## What it demonstrates--- Vision-based page-to-markdown conversion using `PipeLLM` with `$vision` model-- Using shared method packages for page extraction-- Batching over pages to process each one independently-- Combining OCR text with page images for accurate extraction--## The Method: `bundle.mthds`--```toml-domain = "extract_generic"-main_pipe = "power_extractor"--[pipe.power_extractor]-type = "PipeSequence"-description = "Update page content with markdown"-inputs = { document = "Document" }-output = "Text[]"-steps = [- { pipe = "github.com/Pipelex/methods/documents->documents.extract_page_contents_and_views",- result = "page_contents" },- { pipe = "write_markdown_from_page_content",- batch_over = "page_contents", batch_as = "page_content",- result = "markdowns" },-]--[pipe.write_markdown_from_page_content]-type = "PipeLLM"-description = "Write markdown from page content"-inputs = { "page_content.page_view" = "Image", page_content = "Page" }-output = "Text"-model = "$vision"-system_prompt = "You are a multimodal LLM, expert at converting images into perfect markdown."-prompt = """-You are given an image which is a view of a document page: $page_content.page_view-You are also given the text extracted from the page by an OCR model.-Your task is to output the perfect markdown of the page.--Here is the text extracted from the page:-{{ page_content.text_and_images.text.text|tag("ocr_text") }}--- Ensure you do not miss any information from the page.-- Output only the markdown, nothing else.-"""-```--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_generic/bundle.mthds \- -i examples/b_basics/document_extract/extract_generic/inputs.json-```--## Related Documentation--- [PipeExtract Operator](../building-methods/pipes/pipe-operators/PipeExtract.md) - Extract text and images from documents-- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Document Extraction](../features/document-extraction.md) - Overview of document extraction capabilitiesdiff --git a/docs/cookbook/extract-invoice.md b/docs/cookbook/extract-invoice.mddeleted file mode 100644index 85a57e391..000000000--- a/docs/cookbook/extract-invoice.md+++ /dev/null@@ -1,78 +0,0 @@-----title: "Invoice Extraction Example"-description: "Extract structured invoice data from PDF documents using a multi-step Pipelex pipeline with vision-based LLM analysis."------# Example: Invoice Extraction--This example processes PDF invoices through a multi-step pipeline: extract pages with views, classify the invoice type, then extract structured data using vision.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_invoice/bundle.mthds)--## What it demonstrates--- Rich structured concept (`Invoice` with 14+ fields including nested `InvoiceDetails`)-- Nested `PipeSequence` (main pipeline batches over pages, sub-pipeline does analyze then extract)-- Vision-based extraction using page views and OCR text-- Using shared method packages for page extraction--## The Method: `bundle.mthds`--### Invoice concept--```toml-[concept.Invoice]-description = "Invoice information extracted from text, supporting both formal bills and receipts"--[concept.Invoice.structure]-invoice_id = { type = "text", description = "Unique identifier for the invoice" }-invoice_number = { type = "text", description = "Invoice number as shown on the document" }-date = { type = "date", description = "Date when the invoice was issued" }-amount_incl_tax = { type = "number", description = "Total amount including taxes" }-amount_excl_tax = { type = "number", description = "Net amount excluding taxes" }-vendor = { type = "text", description = "Name of the vendor/seller" }-category = { type = "concept", concept_ref = "invoice_extraction.InvoiceDetails", description = "Category or type of expense" }-# ... and more fields-```--### Pipeline--```toml-[pipe.process_invoice]-type = "PipeSequence"-inputs = { document = "Document" }-output = "Invoice[]"-steps = [- { pipe = "github.com/Pipelex/methods/documents->documents.extract_page_contents_and_views", result = "invoice_pages" },- { pipe = "extract_invoice", batch_over = "invoice_pages", batch_as = "invoice_page", result = "invoice" },-]-```--Each page goes through a sub-pipeline that first classifies the invoice type (bill vs. receipt), then extracts the full structured data using both the page view and OCR text:--```toml-[pipe.extract_invoice]-type = "PipeSequence"-inputs = { invoice_page = "Page" }-output = "Invoice"-steps = [- { pipe = "analyze_invoice", result = "invoice_details" },- { pipe = "extract_invoice_data", result = "invoice" },-]-```--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_invoice/bundle.mthds \- -i examples/b_basics/document_extract/extract_invoice/inputs.json-```--## Related Documentation--- [PipeExtract Operator](../building-methods/pipes/pipe-operators/PipeExtract.md) - Extract text and images from documents-- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflows-- [Document Extraction](../features/document-extraction.md) - Overview of document extraction capabilitiesdiff --git a/docs/cookbook/extract-markdown.md b/docs/cookbook/extract-markdown.mddeleted file mode 100644index 6b62f05e1..000000000--- a/docs/cookbook/extract-markdown.md+++ /dev/null@@ -1,61 +0,0 @@-----title: "Extract Markdown from Document"-description: "Extract clean markdown text from any PDF document using Pipelex document extraction and page composition."------# Example: Extract Markdown from Document--This example extracts text from a PDF document and composes the pages into a single clean markdown output. It leverages the shared `documents` method package for page extraction.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_markdown/bundle.mthds)--## What it demonstrates--- Using shared method packages (`github.com/Pipelex/methods/documents`)-- `PipeCompose` with Jinja2 templates to concatenate page text-- Simple two-step document-to-markdown pipeline--## The Method: `bundle.mthds`--The pipeline uses a shared extraction pipe and then composes all pages into a single text:--```toml-domain = "extract_markdown"-main_pipe = "extract_markdown_from_document"--[pipe.extract_markdown_from_document]-type = "PipeSequence"-description = "Extract markdown from a document"-inputs = { document = "Document" }-output = "Text"-steps = [- { pipe = "github.com/Pipelex/methods/documents->documents.extract_markdown_pages", result = "pages" },- { pipe = "write_markdown_from_pages", result = "markdown" },-]--[pipe.write_markdown_from_pages]-type = "PipeCompose"-description = "Write markdown from pages"-inputs = { pages = "Page[]" }-output = "Text"-template = """-{% for page in pages %}-{{ page.text_and_images.text }}-{% endfor %}-"""-```--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_markdown/bundle.mthds \- -i examples/b_basics/document_extract/extract_markdown/inputs.json-```--## Related Documentation--- [PipeExtract Operator](../building-methods/pipes/pipe-operators/PipeExtract.md) - Extract text and images from documents-- [PipeCompose Operator](../building-methods/pipes/pipe-operators/PipeCompose.md) - Template-based data composition-- [Packages](../building-methods/packages.md) - Using shared method packagesdiff --git a/docs/cookbook/extract-proof-of-purchase.md b/docs/cookbook/extract-proof-of-purchase.mddeleted file mode 100644index 69472aa68..000000000--- a/docs/cookbook/extract-proof-of-purchase.md+++ /dev/null@@ -1,73 +0,0 @@-----title: "Proof of Purchase Extraction"-description: "Extract structured data from receipts and invoices using vision-based AI — including products, amounts, and payment details."------# Example: Proof of Purchase Extraction--This example extracts structured data from receipts and invoices. It defines nested data concepts (`Product` inside `ProofOfPurchase`) and uses vision-based extraction to capture all details from the document.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_proof_of_purchase/bundle.mthds)--## What it demonstrates--- Nested structured concepts (`Product` referenced inside `ProofOfPurchase`)-- Vision-based extraction with `$vision` model and `structuring_method = "preliminary_text"`-- Using shared method packages for page extraction-- Batching over pages to process each independently--## The Method: `bundle.mthds`--### Concepts--```toml-[concept.Product]-description = "A product in a proof of purchase"--[concept.Product.structure]-name = { type = "text", description = "Name of the product" }-quantity = { type = "integer", description = "Quantity purchased" }-unit_price = { type = "number", description = "Unit price of the product" }-total_price = { type = "number", description = "Total price for this product" }--[concept.ProofOfPurchase]-description = "Elements from a proof of purchase"--[concept.ProofOfPurchase.structure]-date_of_purchase = { type = "date", description = "Date of the purchase" }-amount_paid = { type = "number", description = "Total amount paid" }-currency = { type = "text", description = "Currency used for the purchase" }-payment_method = { type = "text", description = "Method of payment used" }-purchase_number = { type = "text", description = "Purchase or receipt number" }-products = { type = "list", item_type = "concept", item_concept_ref = "extract_proof_of_purchase.Product", description = "List of products purchased" }-```--### Pipeline--```toml-[pipe.power_extractor_proof_of_purchase]-type = "PipeSequence"-inputs = { document = "Document" }-output = "ProofOfPurchase[]"-steps = [- { pipe = "github.com/Pipelex/methods/documents->documents.extract_page_contents_and_views",- result = "page_contents" },- { pipe = "write_markdown_from_page_content_proof_of_purchase",- batch_over = "page_contents", batch_as = "page_content",- result = "proof_of_purchase" },-]-```--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_proof_of_purchase/bundle.mthds \- -i examples/b_basics/document_extract/extract_proof_of_purchase/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Document Extraction](../features/document-extraction.md) - Overview of document extraction capabilitiesdiff --git a/docs/cookbook/extract-slides.md b/docs/cookbook/extract-slides.mddeleted file mode 100644index 05c23daa8..000000000--- a/docs/cookbook/extract-slides.md+++ /dev/null@@ -1,63 +0,0 @@-----title: "Extract Slides from Presentation"-description: "Extract slide content and descriptions from presentation documents using vision-based LLM analysis with Pipelex."------# Example: Extract Slides from Presentation--This example extracts structured slide information from a presentation document — including titles, content as markdown, and visual descriptions of each slide layout.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_slides/bundle.mthds)--## What it demonstrates--- Custom `Slide` concept with inline structure (title, text, description)-- Vision-based slide analysis using `PipeLLM` with page views-- Batching over extracted pages to process each slide individually-- `PipeCompose` for assembling structured output into formatted text--## The Method: `bundle.mthds`--### Slide concept--```toml-[concept.Slide]-description = "A slide from a presentation"--[concept.Slide.structure]-title = { type = "text", description = "The title of the slide" }-text_markdown = { type = "text", description = "The content of the slide as markdown" }-description = { type = "text", description = "A description of the slide: layout of the text, description of the graphics" }-```--### Pipeline--The pipeline extracts pages with views, describes each slide using a vision model, then concatenates the descriptions:--```toml-[pipe.extract_slides]-type = "PipeSequence"-description = "Extract markdown from a document"-inputs = { document = "Document" }-output = "Text"-steps = [- { pipe = "extract_markdown_and_views_from_document", result = "pages" },- { pipe = "describe_slide", batch_over = "pages", batch_as = "page", result = "slides" },- { pipe = "concatenate_slide_descriptions", result = "slides_description" },-]-```--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_slides/bundle.mthds \- -i examples/b_basics/document_extract/extract_slides/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeExtract Operator](../building-methods/pipes/pipe-operators/PipeExtract.md) - Extract text and images from documents-- [PipeCompose Operator](../building-methods/pipes/pipe-operators/PipeCompose.md) - Template-based data compositiondiff --git a/docs/cookbook/extract-table.md b/docs/cookbook/extract-table.mddeleted file mode 100644index 7015b76c1..000000000--- a/docs/cookbook/extract-table.md+++ /dev/null@@ -1,64 +0,0 @@-----title: "Table Extraction from Image"-description: "Turn table images into structured HTML with Pipelex — using an extract-and-review self-correction pattern."------# Example: Table Extraction from Image--This example extracts a table from an image and converts it into structured HTML. It uses a two-step "extract and review" pattern where the first pipe does the initial extraction and the second pipe reviews the result against the original image to correct errors.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/document_extract/extract_table/bundle.mthds)--## What it demonstrates--- Self-correction pattern: extract then review against the original image-- Custom structured concept (`HtmlTable` with title and HTML content)-- Vision-based extraction using `$vision-table` model-- Multi-modal inputs (image + structured data) in a single pipe--## The Method: `bundle.mthds`--### Pipeline--```toml-[pipe.extract_html_table_and_review]-type = "PipeSequence"-description = "Get an HTML table and review it"-inputs = { table_screenshot = "TableScreenshot" }-output = "HtmlTable"-steps = [- { pipe = "extract_html_table_from_image", result = "html_table" },- { pipe = "review_html_table", result = "reviewed_html_table" },-]--[pipe.review_html_table]-type = "PipeLLM"-description = "Review an HTML table"-inputs = { table_screenshot = "TableScreenshot", html_table = "HtmlTable" }-output = "HtmlTable"-prompt = """-Your role is to correct an html_table to make sure that it matches the one in the provided image: $table_screenshot--@html_table--Pay attention to the text and formatting (color, borders, ...).-Rewrite the entire html table with your potential corrections.-Make sure you do not forget any text.-"""-```--This self-correction pattern is a key technique for building robust AI methods — the first step provides a draft, and the second step verifies and corrects it against the source.--## How to run--```bash-pipelex run bundle examples/b_basics/document_extract/extract_table/bundle.mthds \- -i examples/b_basics/document_extract/extract_table/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/cookbook/gen-expense-data.md b/docs/cookbook/gen-expense-data.mddeleted file mode 100644index ae402bc4d..000000000--- a/docs/cookbook/gen-expense-data.md+++ /dev/null@@ -1,79 +0,0 @@-----title: "Expense Data Generation Example"-description: "Generate realistic synthetic expense reports with receipts, including fraud scenarios, using a complex multi-level Pipelex pipeline."------# Example: Expense Data with Receipts--This advanced example generates complete synthetic expense datasets for multiple employees, including realistic receipt images and HTML reports. It features fraud scenario generation for testing expense validation systems.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/c_advanced/gen_expense_data/bundle.mthds)--## What it demonstrates--- Deep concept hierarchy (Employee, ExpenseScenario, CompanyProfile, ReceiptContent, Expense, etc.)-- Nested `PipeSequence` pipelines (main pipeline batches over employees, sub-pipeline batches over categories)-- `PipeImgGen` for generating realistic receipt images-- `PipeCompose` with `construct` for assembling structured objects from parts-- `PipeCompose` with HTML templates for report rendering-- Fraud scenario modeling (weekend expenses, inflated amounts, receipt mismatches, vague purposes)-- Custom Python runner for post-processing (PDF generation, file export)--## The Method: `bundle.mthds`--### Concept hierarchy (simplified)--```-NbOfEmployees (input, refines Number)- -> Employee[]- -> CompanyCategory[] (with ExpenseScenario)- -> CompanyProfile- -> ReceiptContent (from ReceiptHeader + ReceiptItemsAndTotals + ExpenseMetadata)- -> Receipt (image via PipeImgGen)- -> Expense + Receipt = ExpenseWithReceipt- -> EmployeeExpenseReport (employee + expenses + HTML report)-```--### Main pipeline--```toml-[pipe.generate_expense_dataset]-type = "PipeSequence"-inputs = { nb_employees = "NbOfEmployees" }-output = "EmployeeExpenseReport[]"-steps = [- { pipe = "generate_employees", result = "employees" },- { pipe = "generate_employee_report", batch_over = "employees", batch_as = "employee", result = "reports" },-]-```--For each employee, the `generate_employee_report` sub-pipeline assigns expense categories (with fraud scenarios), then for each category generates a company profile, receipt content, receipt image, and expense record.--### Receipt generation--Receipt content is built in multiple steps: header (transaction number, date), items and totals (from the company's product catalog), and business purpose metadata. These are composed into formatted thermal-paper-style text, then rendered as a photo using `PipeImgGen`.--## How to run--**Using the CLI:**--```bash-pipelex run bundle examples/c_advanced/gen_expense_data/bundle.mthds \- -i examples/c_advanced/gen_expense_data/inputs.json-```--**Using the Python runner** (for PDF export and file organization):--```bash-cd examples/c_advanced/gen_expense_data-python run_generate_expense_dataset.py-```--## Related Documentation--- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflows-- [PipeImgGen Operator](../building-methods/pipes/pipe-operators/PipeImgGen.md) - Generate images from prompts-- [PipeCompose Operator](../building-methods/pipes/pipe-operators/PipeCompose.md) - Template-based data composition-- [Understanding Multiplicity](../building-methods/pipes/understanding-multiplicity.md) - How batching worksdiff --git a/docs/cookbook/gen-synthetic-data.md b/docs/cookbook/gen-synthetic-data.mddeleted file mode 100644index de9caa52e..000000000--- a/docs/cookbook/gen-synthetic-data.md+++ /dev/null@@ -1,70 +0,0 @@-----title: "Synthetic Data Generation Example"-description: "Generate diverse synthetic data samples from a description using a two-step pipeline that identifies cases then creates profiles for each."------# Example: Synthetic Data Generation--This example generates diverse synthetic data samples from a text description. It first identifies a comprehensive set of sample cases, then creates detailed profiles for each one.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/c_advanced/gen_synthetic_data/bundle.mthds)--## What it demonstrates--- Concept refinement (`DataDescription` refines `Text`, `NbOfSamples` refines `Number`)-- Rich structured concept with constrained choices (`Sample` with `current_performance`, `learns_best_with`, etc.)-- Two-step generation: identify diverse cases, then create a profile for each-- Batching over identified cases to generate samples in parallel--## The Method: `bundle.mthds`--### Sample concept--The `Sample` concept represents a student profile with constrained fields:--```toml-[concept.Sample]-description = "A complete synthetic data record representing a student profile."--[concept.Sample.structure]-student_name = { type = "text", description = "The name of the student", required = true }-current_performance = { type = "text", description = "The student's current performance level", choices = [- "Struggling", "Average", "Advanced",-], required = true }-learns_best_with = { type = "text", description = "The learning modality that works best", choices = [- "Visual examples", "Step-by-step text", "Hands-on practice", "Videos",-], required = true }-# ... pace, complexity, strengths, needs_help_with, etc.-```--### Pipeline--```toml-[pipe.generate_synthetic_data_samples]-type = "PipeSequence"-inputs = { data_description = "DataDescription", nb_samples = "NbOfSamples" }-output = "Sample[]"-steps = [- { pipe = "identify_sample_cases", result = "cases" },- { pipe = "create_profile_for_case", result = "samples",- batch_over = "cases", batch_as = "case_characterization" },-]-```--The first step identifies diverse real-world scenarios to ensure comprehensive coverage (edge cases, common scenarios, important variations). The second step creates a full profile for each case.--## How to run--```bash-pipelex run bundle examples/c_advanced/gen_synthetic_data/bundle.mthds \- -i examples/c_advanced/gen_synthetic_data/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflows-- [Understanding Multiplicity](../building-methods/pipes/understanding-multiplicity.md) - How batching works-- [Refining Concepts](../building-methods/concepts/refining-concepts.md) - How concept refinement worksdiff --git a/docs/cookbook/generate-image.md b/docs/cookbook/generate-image.mddeleted file mode 100644index 8c4de0051..000000000--- a/docs/cookbook/generate-image.md+++ /dev/null@@ -1,70 +0,0 @@-----title: "Generate Image Example"-description: "Generate creative, absurd images using a multi-step pipeline that imagines a scene, crafts a prompt, and renders the image."------# Example: Generate Image--This example generates creative, absurd images through a three-step pipeline: imagine a surreal scene concept, refine it into an optimized image prompt, then render the image.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/b_basics/generate_visuals/gen_image/bundle.mthds)--## What it demonstrates--- Concept refinement (`SceneConcept` and `ImagePrompt` both refine `Text`)-- `PipeImgGen` for image generation-- Multi-step creative pipeline where each step builds on the previous one-- No external inputs required — the pipeline generates everything from scratch--## The Method: `bundle.mthds`--```toml-domain = "crazy_image_generation"-main_pipe = "generate_crazy_image"--[concept.SceneConcept]-description = "A creative, abstract description of an absurd and surreal scene."-refines = "Text"--[concept.ImagePrompt]-description = "A detailed textual description optimized for image generation models."-refines = "Text"--[pipe.generate_crazy_image]-type = "PipeSequence"-description = "Main pipeline that imagines a scene, refines it into a prompt, and renders the image"-output = "Image"-steps = [- { pipe = "imagine_scene", result = "scene_concept" },- { pipe = "generate_img_prompt", result = "image_prompt" },- { pipe = "render_image", result = "crazy_image" },-]-```--The `render_image` pipe uses `PipeImgGen` to generate the final image:--```toml-[pipe.render_image]-type = "PipeImgGen"-description = "Generates the absurd image based on the creative scene description"-inputs = { image_prompt = "ImagePrompt" }-output = "Image"-prompt = "$image_prompt"-model = "@default-small"-```--## How to run--```bash-pipelex run bundle examples/b_basics/generate_visuals/gen_image/bundle.mthds-```--No inputs needed — the pipeline imagines everything from scratch.--## Related Documentation--- [PipeImgGen Operator](../building-methods/pipes/pipe-operators/PipeImgGen.md) - Generate images from prompts-- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Refining Concepts](../building-methods/concepts/refining-concepts.md) - How concept refinement worksdiff --git a/docs/cookbook/hello-world.md b/docs/cookbook/hello-world.mddeleted file mode 100644index 25d2d1023..000000000--- a/docs/cookbook/hello-world.md+++ /dev/null@@ -1,63 +0,0 @@-----title: "Hello World Example"-description: "The Hello World of Pipelex — a simple pipeline demonstrating basic concepts. Verify your installation and get a first taste of how Pipelex works."------# Example: Hello World--This is the "Hello World" of Pipelex, a simple pipeline that demonstrates the basic concepts of Pipelex.--It's the perfect starting point to verify your installation and get a first taste of how Pipelex works.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/a_quick_start/hello_world.mthds)--## What it demonstrates--- Minimal Pipelex setup with a single `PipeLLM` pipe-- The `main_pipe` field to designate the entry point-- Running a method bundle from the CLI--## The Method: `hello_world.mthds`--The method definition is extremely simple — a single LLM call that generates a haiku:--```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.-"""-```--## How to run--1. Clone the cookbook repository and install dependencies:-- ```bash- git clone https://github.com/Pipelex/pipelex-cookbook.git- cd pipelex-cookbook- pip install .- ```--2. Set up your environment variables by copying `.env.example` to `.env` and adding your API keys.--3. Run the example:-- ```bash- pipelex run bundle examples/a_quick_start/hello_world.mthds- ```--Expected output: A haiku about "Hello World" displayed with pretty formatting.--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Define Your Concepts](../building-methods/concepts/define_your_concepts.md) - How to define custom data types for your methodsdiff --git a/docs/cookbook/index.md b/docs/cookbook/index.mdindex c25274cfe..4a6e7fe8e 100644--- a/docs/cookbook/index.md+++ b/docs/cookbook/index.md@@ -1,56 +1,18 @@----title: "Cookbook Examples"-description: "Practical Pipelex examples and ready-to-use recipes: Hello World, document extraction, visual generation, synthetic data, and more."+title: "The Pipelex Cookbook"+description: "The Pipelex Cookbook holds Pipelex's example methods, each one runnable by its address on the hosted Pipelex API, with a page showing every way to use it."----# Pipelex Cookbook Examples+# The Pipelex Cookbook-Welcome to the Pipelex Cookbook!+[](https://github.com/Pipelex/pipelex-cookbook)-[](https://github.com/Pipelex/pipelex-cookbook/tree/main)+The [Pipelex Cookbook](https://github.com/Pipelex/pipelex-cookbook) holds Pipelex's example methods. Each one is a package that runs by its address on the hosted Pipelex API, `github.com/Pipelex/pipelex-cookbook/<method>@<release>`, so there is nothing to clone and nothing to install before you try it. Each method's page gives its address at the cookbook's latest release.-This is your go-to resource for practical examples and ready-to-use recipes to build powerful and reliable AI methods with Pipelex. Whether you're a beginner looking to get started or an experienced user searching for advanced patterns, you'll find something useful here.+Every method has its own page in the cookbook, and every page shows the same ways to use it: in your chatbot through the Pipelex MCP, in your coding agent through the Pipelex plugin, in your code through the TypeScript or Python SDK or over HTTP, as a web app made from the method-app template, and how to make it yours by copying it, changing it and saving it to your account. The [list of methods](https://github.com/Pipelex/pipelex-cookbook#methods-you-can-run-by-address) on the cookbook's front page links to each page, and the page for [Gantt chart extraction](https://github.com/Pipelex/pipelex-cookbook/tree/main/methods/extract_gantt) is a good one to start with.-We strongly encourage you to clone the [Pipelex Cookbook repository](https://github.com/Pipelex/pipelex-cookbook/tree/main), play with the examples, and tailor them to your specific needs.+The cookbook also has [recipes](https://github.com/Pipelex/pipelex-cookbook/tree/main/recipes), each of which takes one way of using a method further on a real case, such as a FastAPI endpoint, a Next.js server action or a web app you deploy. Its [tutorial](https://github.com/Pipelex/pipelex-cookbook/tree/main/tutorial) teaches you to write methods in MTHDS by hand and to run them on your own machine.-## Quick Start+The methods Pipelex publishes as reusable building blocks, such as invoice extraction and table extraction, live in the [method library](https://github.com/Pipelex/methods) instead, and they run by their address in the same way.-- [**Hello World**](./hello-world.md) — The simplest Pipelex pipeline: a single LLM call that generates a haiku.-- [**Summarize**](./summarize.md) — Multi-step text summarization with topic extraction and batching.--## Document Extraction--- [**Generic Document**](./extract-generic.md) — Extract markdown from complex PDFs using vision.-- [**Invoice**](./extract-invoice.md) — Extract structured invoice data with classification and vision analysis.-- [**Proof of Purchase**](./extract-proof-of-purchase.md) — Extract receipt data including product lists.-- [**DPE (Energy Diagnostic)**](./extract-dpe.md) — Specialized extraction for French energy performance certificates.-- [**Table from Image**](./extract-table.md) — Convert table images to HTML with self-correction review.-- [**Gantt Chart**](./extract-gantt.md) — Extract tasks and dates from Gantt chart images using divide-and-conquer.-- [**Markdown from Document**](./extract-markdown.md) — Simple document-to-markdown using shared method packages.-- [**Slides from Presentation**](./extract-slides.md) — Extract slide content and descriptions with vision analysis.-- [**CV Batch Screening**](./cv-batch-screening.md) — Extract a stack of CVs and a job offer, then score each candidate against the role.--## Visual Generation--- [**Design Slides**](./design-slides.md) — Generate themed slide design proposals with visual mockups.-- [**Generate Image**](./generate-image.md) — Creative image generation through a three-step pipeline.--## Advanced--- [**Synthetic Data**](./gen-synthetic-data.md) — Generate diverse synthetic data samples from a description.-- [**Expense Data with Receipts**](./gen-expense-data.md) — Generate complete expense datasets with receipt images and fraud scenarios.-- [**Using Inference Plugins**](./using-inference-plugins.md) — Install an inference-backend plugin and run a method against the model it serves, with zero API keys.--## Work in Progress--These examples are under active development and may change:--- [**Tweet Optimizer**](./write-tweet.md) — Analyze and optimize tech tweets with style transfer.-- [**Blog Article Generator**](./blog-article-generator.md) — Generate SEO-optimized articles from structured requests.-- [**Advisory Board**](./advisory-board.md) — Multi-board business consultation with consensus analysis.-- [**Discord Newsletter**](./discord-newsletter.md) — Generate HTML newsletters from Discord channel data.-- [**Expense Validation**](./validate-expense-data.md) — Validate expense reports against company policies.--## Contribute--Have you built a cool pipeline with Pipelex? Share it with the community! We welcome contributions. Check out our [contribution guidelines](../contributing.md) and help us grow this collection of examples.+This documentation explains each part of Pipelex once, as a reference, and the cookbook shows each of them working on a real method. If you have not used Pipelex yet, the [Quick Start](../get-started/quick-start.md) sets up the Pipelex plugin and the Pipelex MCP that the cookbook's pages rely on.diff --git a/docs/cookbook/summarize.md b/docs/cookbook/summarize.mddeleted file mode 100644index b9853f6b0..000000000--- a/docs/cookbook/summarize.md+++ /dev/null@@ -1,86 +0,0 @@-----title: "Summarize Example"-description: "Summarize text using a multi-step pipeline that extracts topics, summarizes each, and combines them into a final summary."------# Example: Summarize--This example demonstrates two approaches to summarizing text: a direct structured summary and a multi-step topic-based summarization pipeline.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/a_quick_start/summarize.mthds)--## What it demonstrates--- Defining custom concepts with inline structures (`StructuredSummary`)-- Multi-step `PipeSequence` with intermediate results-- Batching over a list of topics (`batch_over` / `batch_as`)-- Two pipes producing different outputs from the same input--## The Method: `summarize.mthds`--### Concepts--The method defines a `StructuredSummary` concept with fields for the summary, an abstract, and a list of main concepts:--```toml-domain = "summarize"-description = "Example of summarizing text by topics."-system_prompt = "You are an expert at summarizing text."--[concept]-Topic = "A topic a text deals with."-Summary = "A concise rewriting of a dense text."--[concept.StructuredSummary]-description = "A summary with a structured output."--[concept.StructuredSummary.structure]-summary = { type = "text", description = "Summary of the text, super clear and factual", required = true }-abstract = { type = "text", description = "Abstract of the summary 1 short sentences", required = true }-main_concepts = { type = "list", item_type = "text", description = "Array of main concepts tackled in the text" }-```--### Multi-step pipeline--The `summarize_by_steps` pipeline breaks summarization into three stages: extract topics, summarize each topic individually (batched), then combine all summaries:--```toml-[pipe.summarize_by_steps]-type = "PipeSequence"-description = "Summarize text by steps: extract topics, summarize for each topic, summarize from summaries."-inputs = { text = "Text" }-output = "Summary"-steps = [- { pipe = "extract_topics", result = "topics" },- { pipe = "summarize_topic", batch_over = "topics", batch_as = "topic", result = "summarized_topics" },- { pipe = "summarize_from_summaries", result = "summary" },-]-```--Each topic is summarized independently using `batch_over`, and the final step merges everything into a single cohesive summary.--## How to run--**Direct structured summary:**--```bash-pipelex run bundle examples/a_quick_start/summarize.mthds \- --pipe summarize_with_structure \- -i examples/a_quick_start/inputs.json-```--**Multi-step topic-based summary:**--```bash-pipelex run bundle examples/a_quick_start/summarize.mthds \- --pipe summarize_by_steps \- -i examples/a_quick_start/inputs.json-```--## Related Documentation--- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflows-- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [Understanding Multiplicity](../building-methods/pipes/understanding-multiplicity.md) - How batching worksdiff --git a/docs/cookbook/using-inference-plugins.md b/docs/cookbook/using-inference-plugins.mddeleted file mode 100644index 9cabd8874..000000000--- a/docs/cookbook/using-inference-plugins.md+++ /dev/null@@ -1,124 +0,0 @@-----title: "Using Inference Plugins Example"-description: "Install a Pipelex inference-backend plugin, watch discovery register it, and run a method against the model it serves — no API key needed."------# Example: Using Inference Plugins--This example shows how Pipelex discovers **inference-backend plugins**: installable Python packages that teach Pipelex how to serve models for a given `sdk` token. The cookbook ships a complete, minimal plugin — a deterministic "LLM" that always answers with the same haiku — so the whole flow runs anywhere with no API key and no network.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/tree/main/examples/c_advanced/using_inference_plugins)--## What it demonstrates--- What a plugin **is**: a package exposing a `pipelex.plugins.kernel` entry point that resolves to a `PipelexPlugin` — an object with a `name`, a `targets_api` version, and a side-effect-free `register(registrar)` method-- Registration through the registrar: `register` contributes an inference backend for `(family="llm", sdk="hello")`, plus an optional model lister-- Discovery by presence: installing the package is the whole integration — no enable-list, no config switch-- The model-config side: how a model handle in a `.mthds` file resolves to the plugin's worker through `.pipelex/inference/`-- The failure mode when the plugin is missing — a loud, friendly error, not a silent fallback--## The plugin package--The plugin lives inside the example directory as its own installable package:--```-examples/c_advanced/using_inference_plugins/-├── hello_plugin.mthds # the method that uses the plugin-served model-└── hello_inference_plugin/ # the plugin package- ├── pyproject.toml # declares the `pipelex.plugins.kernel` entry point- └── hello_inference_plugin/- ├── hello_plugin.py # HelloInferencePlugin: name, targets_api, register()- ├── hello_llm_worker.py # HelloLLMWorker(LLMWorkerAbstract): the actual "model"- └── hello_list.py # optional lister behind `pipelex show models hello`-```--The entry point in `pyproject.toml` is the single line that wires everything:--```toml-[project.entry-points."pipelex.plugins.kernel"]-hello_inference = "hello_inference_plugin.hello_plugin:HelloInferencePlugin"-```--The plugin class registers what it serves — and nothing else happens at registration time (no I/O, no client construction; heavy work belongs inside the worker factory):--```python-class HelloInferencePlugin:- name = "hello_inference"- targets_api = PLUGIN_API_VERSION-- def register(self, registrar: PluginRegistrar) -> None:- registrar.add_inference_backend(family=InferenceFamily.LLM, sdk="hello", make_worker=_make_hello_llm_worker)- registrar.add_model_lister(sdk="hello", lister=_list_hello_models)-```--The worker subclasses `LLMWorkerAbstract` and only implements the generation itself — the base class owns the job lifecycle, capability checks, usage reporting, and telemetry. Here it deterministically returns a haiku; a real plugin would call a remote model at this exact spot.--## The model-config side--Model configuration lives in the project's `.pipelex/inference/` directory (not in `.pipelex/pipelex.toml`). Three pieces connect a `.mthds` model handle to the plugin:--- `backends.toml` declares the `[hello]` backend (enabled, no API key)-- `backends/hello.toml` declares model `hello-1` with `sdk = "hello"` — the token that selects the plugin's worker factory-- `routing_profiles.toml` routes `hello-1` to the `hello` backend via an `optional_routes` entry, which only applies while the target backend is enabled--## The Method: `hello_plugin.mthds`--```toml-domain = "hello_plugin"-description = "Using a model served by an inference-backend plugin"-main_pipe = "hello_plugin"--[pipe]-[pipe.hello_plugin]-type = "PipeLLM"-description = "Write text about Hello World."-output = "Text"-model = { model = "hello-1", temperature = 0.5 }-prompt = """-Write a haiku about Hello World.-"""-```--The only difference from the standard [Hello World](./hello-world.md) example is the `model` field: `hello-1` is served by the plugin instead of a gateway backend.--## How to run--1. Install the plugin package (this is the step being demonstrated):-- ```bash- uv pip install -e examples/c_advanced/using_inference_plugins/hello_inference_plugin- ```--2. Check that Pipelex discovered it:-- ```bash- pipelex plugins list # hello_inference | external | registered- pipelex show models hello # lists hello-1- ```--3. Run the method — no credentials needed:-- ```bash- pipelex run bundle examples/c_advanced/using_inference_plugins/hello_plugin.mthds- ```-- The output is the plugin's deterministic haiku.--## The failure mode--Uninstall the package and run again:--```bash-uv pip uninstall hello-inference-plugin-pipelex run bundle examples/c_advanced/using_inference_plugins/hello_plugin.mthds-```--Pipelex fails loud at worker-creation time: `No inference backend registered for sdk 'hello' in the llm family. Is its plugin installed and enabled?` — the model config still resolves; only the worker factory is missing. A dry run still passes without the plugin, because worker creation is lazy.--## Related Documentation--- [Inference Backend Plugins](../under-the-hood/inference-backend-plugins.md) - The plugin seam and the Inference SPI, including how to wrap a real SDK (dependency guards, client memoization)-- [Configuration System](../features/configuration.md) - How `.pipelex/` project configuration works-- [Pipelex Gateway & Model Access](../features/gateway.md) - Default model access through the gatewaydiff --git a/docs/cookbook/validate-expense-data.md b/docs/cookbook/validate-expense-data.mddeleted file mode 100644index 33f233626..000000000--- a/docs/cookbook/validate-expense-data.md+++ /dev/null@@ -1,85 +0,0 @@-----title: "Expense Validation Example"-description: "Validate expense reports against company policies using a comprehensive Pipelex pipeline combining LLM checks, Python functions, and vision analysis."------# Example: Expense Validation--!!! warning "Work in Progress"- This example is under active development and may change.--This example validates expense reports against company policies. It extracts data from PDF reports, then runs each expense through multiple validation checks — including receipt matching with vision, spending limits, weekend policy, purpose quality assessment, and amount reasonableness.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/wip/validate_expense_data/validation.mthds)--## What it demonstrates--- `PipeFunc` for Python-based validation logic (spending limits, weekend checks, timeliness)-- `PipeLLM` with vision for receipt matching-- `PipeLLM` for subjective assessments (purpose quality, amount reasonableness)-- `PipeExtract` for PDF parsing-- Complex validation pipeline combining 6 different checks per expense-- Rich result concepts with detailed approval status and statistics--## The Method: `validation.mthds`--### Validation pipeline--```toml-[pipe.validate_expense_report]-type = "PipeSequence"-inputs = { expense_pdf = "ExpenseReportPDF", receipts = "ReceiptImage[]" }-output = "ValidationReport"-steps = [- { pipe = "extract_pdf_content", result = "pages" },- { pipe = "parse_expense_report", result = "report" },- { pipe = "extract_expenses_list", result = "expenses" },- { pipe = "validate_single_expense", batch_over = "expenses", batch_as = "expense",- result = "expense_validations" },- { pipe = "compose_validation_report", result = "validation_report" },-]-```--### Per-expense validation--Each expense goes through 6 checks, then results are composed:--```toml-[pipe.validate_single_expense]-type = "PipeSequence"-inputs = { report = "ExpenseReport", expense = "Expense", receipts = "ReceiptImage[]" }-output = "ExpenseValidationResult"-steps = [- { pipe = "check_receipt_match", result = "receipt_check" },- { pipe = "check_spending_limit", result = "limit_check" },- { pipe = "check_weekend", result = "weekend_check" },- { pipe = "check_timeliness", result = "timeliness_check" },- { pipe = "check_purpose_quality", result = "purpose_check" },- { pipe = "check_reasonable_amount", result = "reasonable_check" },- { pipe = "compose_expense_result", result = "validation_result" },-]-```--The checks use a mix of:--- **`PipeFunc`**: Deterministic checks (spending limits, weekend detection, timeliness)-- **`PipeLLM`**: Subjective assessments (purpose quality, amount reasonableness)-- **`PipeLLM` with vision**: Receipt-to-expense matching--## How to run--This example requires a custom Python runner:--```bash-cd examples/wip/validate_expense_data-python run_validate_expenses.py-```--## Related Documentation--- [PipeFunc Operator](../building-methods/pipes/pipe-operators/PipeFunc.md) - Call Python functions from pipes-- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeExtract Operator](../building-methods/pipes/pipe-operators/PipeExtract.md) - Extract text and images from documents-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/cookbook/write-tweet.md b/docs/cookbook/write-tweet.mddeleted file mode 100644index 98d1638ac..000000000--- a/docs/cookbook/write-tweet.md+++ /dev/null@@ -1,65 +0,0 @@-----title: "Tweet Optimizer Example"-description: "Optimize tech tweets with style transfer using Pipelex — analyze for pitfalls then rewrite based on a reference writing style."------# Example: Tweet Optimizer--!!! warning "Work in Progress"- This example is under active development and may change.--This example takes a draft tweet and a reference writing style, then optimizes the tweet through a two-step "analyze and optimize" pipeline. The analysis step checks for common pitfalls (fluffiness, cringiness, humblebragginess, vagueness), and the optimization step rewrites the tweet based on that analysis.--## Get the code--[](https://github.com/Pipelex/pipelex-cookbook/blob/main/examples/wip/write_tweet/tech_tweet.mthds)--## What it demonstrates--- Two-step "analyze then refine" pattern-- Multiple inputs (`DraftTweet`, `WritingStyle`) flowing into a `PipeSequence`-- Specialized model references (`$writing-factual`, `$writing-creative`)-- Simple concept definitions without structures (text-only concepts)--## The Method: `tech_tweet.mthds`--### Concepts--```toml-domain = "tech_tweet"-main_pipe = "optimize_tweet_sequence"--[concept]-DraftTweet = "A draft version of a tech tweet that needs optimization"-OptimizedTweet = "A tweet optimized for Twitter/X engagement following best practices"-TweetAnalysis = "Analysis of the tweet's structure and potential improvements"-WritingStyle = "A style of writing"-```--### Pipeline--```toml-[pipe.optimize_tweet_sequence]-type = "PipeSequence"-description = "Analyze and optimize a tech tweet in sequence"-inputs = { draft_tweet = "DraftTweet", writing_style = "WritingStyle" }-output = "OptimizedTweet"-steps = [- { pipe = "analyze_tweet", result = "tweet_analysis" },- { pipe = "optimize_tweet", result = "optimized_tweet" },-]-```--The analysis pipe evaluates the tweet for fluffiness, cringiness, humblebragginess, and vagueness — scoring each 1-5. The optimization pipe then rewrites based on this analysis and the reference writing style.--## How to run--```bash-pipelex run bundle examples/wip/write_tweet/tech_tweet.mthds \- -i examples/wip/write_tweet/inputs.json-```--## Related Documentation--- [PipeLLM Operator](../building-methods/pipes/pipe-operators/PipeLLM.md) - The core operator for LLM interactions-- [PipeSequence Controller](../building-methods/pipes/pipe-controllers/PipeSequence.md) - Chain pipes into sequential workflowsdiff --git a/docs/features/document-extraction.md b/docs/features/document-extraction.mdindex e64f04aa6..aa34ae4ce 100644--- a/docs/features/document-extraction.md+++ b/docs/features/document-extraction.md@@ -41,4 +41,4 @@ Include PDFs directly in your prompts using `@variable` syntax. PipeLLM automati## Related Documentation- [PipeExtract](../building-methods/pipes/pipe-operators/PipeExtract.md) - Operator reference and MTHDS fields-- [Generic Document Extraction Example](../cookbook/extract-generic.md) - Extract markdown from complex PDFs using vision+- [Generic document extraction](https://github.com/Pipelex/pipelex-cookbook/tree/main/methods/extract_generic) - A cookbook method that returns each page of any document as Markdown, including the text inside its images and diagramsdiff --git a/docs/cookbook/cv-batch-screening.md b/docs/get-started/cv-batch-screening.mdsimilarity index 97%rename from docs/cookbook/cv-batch-screening.mdrename to docs/get-started/cv-batch-screening.mdindex bc942d333..7f7626dde 100644--- a/docs/cookbook/cv-batch-screening.md+++ b/docs/get-started/cv-batch-screening.md@@ -1,11 +1,11 @@----title: "CV Batch Screening Example"-description: "Screen a stack of CVs against a job offer with a multi-step Pipelex method that extracts each document, analyzes it and scores the match."+title: "CV Batch Screening, Step by Step"+description: "Screen a stack of CVs against a job offer with a multi-step Pipelex method that extracts each document, analyzes it and scores the match, run on your own machine from the CLI and from Python."----# Example: CV Batch Screening+# CV Batch Screening, Step by Step-A production method that takes a stack of CVs and a job offer PDF, extracts and analyzes each, then scores how well each candidate matches the role.+A production method that takes a stack of CVs and a job offer PDF, extracts and analyzes each, then scores how well each candidate matches the role. This page reads it part by part and runs it on your own machine with the Pipelex runtime, from the CLI and from Python, once you have followed [Run It Yourself](./run-it-yourself.md).## What it demonstratesdiff --git a/docs/get-started/mthds-language-tutorial.md b/docs/get-started/mthds-language-tutorial.mdindex 645b1c606..9ac70c53a 100644--- a/docs/get-started/mthds-language-tutorial.md+++ b/docs/get-started/mthds-language-tutorial.md@@ -222,8 +222,8 @@ Learn more about concepts in [Define Your Concepts](../building-methods/conceptsYou now understand the building blocks: pipes, sequences, inputs, and structured outputs.-- **Tutorial** — more lessons in the [Cookbook](../cookbook/index.md) (document extraction, batch processing, and more)+- **Tutorial** — more lessons in the [cookbook's tutorial](https://github.com/Pipelex/pipelex-cookbook/tree/main/tutorial), from structured outputs to model settings, batches and parallel steps- **Build Reliable AI Methods** — deep dive into [method project design](../building-methods/kick-off-a-methods-project.md)- **Pipe Operators & Controllers** — reference for [pipe operators](../building-methods/pipes/pipe-operators/index.md) (PipeLLM, PipeExtract, PipeCompose, ...) and [pipe controllers](../building-methods/pipes/pipe-controllers/index.md) (PipeSequence, PipeParallel, PipeBatch, PipeCondition)-- **Cookbook Examples** — real-world [examples and patterns](../cookbook/index.md)+- **The Cookbook** — [example methods](../cookbook/index.md) you run by their address, with every way to use each one- **CLI Reference** — full [command-line reference](../tools/cli/index.md)diff --git a/docs/get-started/run-it-yourself.md b/docs/get-started/run-it-yourself.mdindex c43a6d802..2df09f8f2 100644--- a/docs/get-started/run-it-yourself.md+++ b/docs/get-started/run-it-yourself.md@@ -77,7 +77,7 @@ Then run it:pipelex run bundle summarize.mthds --inputs inputs.json```-The result is written under `results/`. From here, [The MTHDS Language Tutorial](./mthds-language-tutorial.md) builds a method step by step, and [CV batch screening](../cookbook/cv-batch-screening.md) runs a method with several steps, typed concepts and a batch, from the CLI and from Python.+The result is written under `results/`. From here, [The MTHDS Language Tutorial](./mthds-language-tutorial.md) builds a method step by step, and [CV batch screening, step by step](./cv-batch-screening.md) runs a method with several steps, typed concepts and a batch, from the CLI and from Python.## Editor extensiondiff --git a/docs/index.md b/docs/index.mdindex d3af52c76..9867fcc7c 100644--- a/docs/index.md+++ b/docs/index.md@@ -31,9 +31,9 @@ Describe how the work gets done in plain English, and your coding agent builds iLearn the declarative language step by step: concepts, pipes, sequences, inputs, and structured outputs.-- :material-book-open-variant: **[Cookbook Examples](./cookbook/index.md)**+- :material-book-open-variant: **[Cookbook](./cookbook/index.md)**- Production-ready recipes — from Hello World to document extraction, synthetic data, and image generation.+ Example methods you run by their address, each with a page showing every way to use it: in your chatbot, in your code, as an app, or as a method of your own.</div>diff --git a/docs/root-index.html b/docs/root-index.htmlindex e0a528f1a..723831097 100644--- a/docs/root-index.html+++ b/docs/root-index.html@@ -35,7 +35,7 @@<li><a href="/latest/get-started/quick-start/">Quick Start</a> — Sign up at <a href="https://app.pipelex.com">app.pipelex.com</a>, install the Pipelex plugin in Claude Code or Codex, and ask your agent for the method you want.</li><li><a href="/latest/get-started/run-it-yourself/">Run It Yourself</a> — Install the Pipelex runtime and run methods on your own machine.</li><li><a href="/latest/get-started/mthds-language-tutorial/">MTHDS Language Tutorial</a> — Learn concepts, pipes, sequences, and structured outputs.</li>-<li><a href="/latest/cookbook/">Cookbook Examples</a> — From Hello World to document extraction and image generation.</li>+<li><a href="/latest/cookbook/">Cookbook</a> — Example methods you run by their address, each with a page showing every way to use it.</li></ul><h2>What a Method Looks Like</h2><p>A method is a reusable, typed AI procedure, written in <a href="https://mthds.ai/latest/">MTHDS</a>, an open standard, and saved as a .mthds file. Each step is explicit, each output is structured, and every run is repeatable.</p>diff --git a/docs/under-the-hood/inference-backend-plugins.md b/docs/under-the-hood/inference-backend-plugins.mdindex fd19ac254..79fbd4853 100644--- a/docs/under-the-hood/inference-backend-plugins.md+++ b/docs/under-the-hood/inference-backend-plugins.md@@ -124,6 +124,8 @@ The same import-light / fail-at-use rules apply: a missing optional extra must r## Authoring a backend plugin (minimal example)+[Writing an Inference Plugin](writing-an-inference-plugin.md) walks through a complete plugin you can install and run with no API key, from its entry point to a method served by its model. The example below shows what a plugin wrapping a real SDK adds to that.+A complete LLM backend plugin for a hypothetical `acme` SDK:```python@@ -248,6 +250,7 @@ The SPI is a documented, versioned **module/symbol list** gated by `PLUGIN_API_V## Related+- [Writing an Inference Plugin](writing-an-inference-plugin.md) — a complete plugin, installed and run end to end with no API key- [Orchestrator Plugins](orchestrator-plugins.md) — the other per-call seam, riding the same discovery/denylist machinery- [Storage Provider Plugins](storage-provider-plugins.md) — the config-selected-singleton seam (storage backend by `runtime.storage.method`)- [Secrets Provider Plugins](secrets-provider-plugins.md) — the config-selected-singleton seam (secrets backend by `runtime.secrets.method`)diff --git a/docs/under-the-hood/writing-an-inference-plugin.md b/docs/under-the-hood/writing-an-inference-plugin.mdnew file mode 100644index 000000000..562a927cb--- /dev/null+++ b/docs/under-the-hood/writing-an-inference-plugin.md@@ -0,0 +1,342 @@+---+title: "Writing an Inference Plugin"+description: "Write, install and run a minimal Pipelex inference-backend plugin: a deterministic model that needs no API key, served to a method through the plugin seam."+---++# Writing an Inference Plugin++An inference plugin is an installable Python package that teaches the Pipelex runtime to serve models for a given `sdk` token. This page builds a complete one, `hello-inference-plugin`, whose "LLM" always answers with the same haiku, so every step runs on your own machine without an API key or a network call. It then declares a model served by the plugin, runs a method against it, and shows what happens when the plugin is missing.++[Inference Backend Plugins](inference-backend-plugins.md) is the reference for the seam this page uses: the plugin contract, the Inference SPI a plugin imports, and the errors discovery raises. This page walks through that seam once, end to end.++!!! note "A plugin extends the runtime on your machine"+ An inference plugin is loaded by the Pipelex runtime you install and run yourself, as in [Run It Yourself](../get-started/run-it-yourself.md). A method you run on the hosted Pipelex API is served by the hosted plane's own backends and cannot use a plugin installed on your machine.++## What you will build++The plugin is its own package:++```+hello-inference-plugin/+├── pyproject.toml # declares the pipelex.plugins.kernel entry point+└── hello_inference_plugin/+ ├── __init__.py # empty+ ├── hello_plugin.py # HelloInferencePlugin: name, targets_api and register()+ ├── hello_llm_worker.py # HelloLLMWorker: the model itself+ └── hello_list.py # an optional lister behind `pipelex show models hello`+```++Two more pieces connect a method to it: a model declared with `sdk = "hello"` in your inference configuration, and a method that names that model.++## Step 1: Declare the entry point++The package's `pyproject.toml` publishes the plugin under the `pipelex.plugins.kernel` entry-point group:++```toml+[project]+name = "hello-inference-plugin"+version = "0.1.0"+description = "Minimal Pipelex inference-backend plugin: a deterministic 'hello' LLM that needs no API key"+requires-python = ">=3.11"+dependencies = ["pipelex"]++# The whole integration: once this distribution is installed, Pipelex discovers the plugin+# through the `pipelex.plugins.kernel` entry-point group. An inference backend builds a worker,+# never a pipe, so it is a kernel-layer plugin and publishes under the kernel group.+[project.entry-points."pipelex.plugins.kernel"]+hello_inference = "hello_inference_plugin.hello_plugin:HelloInferencePlugin"++[build-system]+requires = ["hatchling"]+build-backend = "hatchling.build"++[tool.hatch.build.targets.wheel]+packages = ["hello_inference_plugin"]+```++That entry point is the whole integration. Pipelex has no list of enabled plugins to edit: an installed plugin is discovered at startup, and its presence is what enables it. The entry point may name the plugin class, as here, or an instance of it.++The group is not cosmetic. It declares the plugin's layer, and an inference backend belongs to the kernel layer because it builds a worker and never a pipe. A plugin published under `pipelex.plugins.interpreter` instead would be invisible to a kernel-only boot, and a plugin still published under the retired `pipelex.plugins` group stops Pipelex from starting, with an error naming the group to move to.++## Step 2: Register what the plugin serves++`hello_plugin.py` holds the plugin class and the two callables it registers:++```python+from pipelex.cogt.inference.inference_worker_abstract import InferenceWorkerAbstract+from pipelex.cogt.model_backends.backend import InferenceBackend+from pipelex.cogt.model_backends.model_spec import InferenceModelSpec+from pipelex.plugins.inference_backend_registry import InferenceFamily+from pipelex.plugins.registrar import PluginRegistrar+from pipelex.plugins.sdk_client_registry import SdkClientRegistry+from pipelex.reporting.reporting_protocol import ReportingProtocol+++def _make_hello_llm_worker(+ *,+ inference_model: InferenceModelSpec,+ backend: InferenceBackend,+ sdk_clients: SdkClientRegistry,+ reporting_delegate: ReportingProtocol | None,+) -> InferenceWorkerAbstract:+ # Heavy work belongs here, inside the closure, never at module import time.+ # A real plugin would call `require_sdk(...)`, then build and memoize its SDK client+ # with `sdk_clients.get_or_create(...)`. The hello worker needs neither.+ from hello_inference_plugin.hello_llm_worker import HelloLLMWorker++ return HelloLLMWorker(inference_model=inference_model, reporting_delegate=reporting_delegate)+++async def _list_hello_models(+ *,+ sdk: str,+ backend_name: str,+ backend: InferenceBackend,+ flat: bool,+ any_listed: bool,+) -> None:+ from hello_inference_plugin.hello_list import list_hello_models++ list_hello_models(sdk=sdk, backend_name=backend_name, backend=backend, flat=flat, any_listed=any_listed)+++class HelloInferencePlugin:+ """An out-of-tree inference-backend plugin serving the `hello` sdk token.++ `register` is the only method Pipelex calls, and it stays free of side effects:+ it calls the registrar's menu methods and nothing else.+ """++ name = "hello_inference"+ # The plugin API version this plugin was written against, as a literal: never import the+ # runtime's PLUGIN_API_VERSION here, or the check that catches a breaking runtime upgrade always passes.+ targets_api = 4++ def register(self, registrar: PluginRegistrar) -> None:+ registrar.add_inference_backend(family=InferenceFamily.LLM, sdk="hello", make_worker=_make_hello_llm_worker)+ # Optional: powers `pipelex show models` for a backend serving this sdk.+ registrar.add_model_lister(sdk="hello", lister=_list_hello_models)+```++A plugin is any object with a `name`, a `targets_api` and a `register` method. `targets_api` is the plugin API version the plugin was written against, written as a number: discovery compares it with the runtime's `PLUGIN_API_VERSION` and refuses the plugin with `PluginApiVersionMismatchError` when they differ, which is how a runtime whose plugin contract changed tells you the plugin needs updating. The runtime's own plugins import the constant because they ship with it; a plugin installed separately must not, or the comparison always passes. Pipelex calls `register` at startup and again whenever `pipelex plugins list` rediscovers the plugins, so it must do nothing but call the registrar's menu methods: no hub access, no I/O and no client construction.++`add_inference_backend` registers a worker factory for one pair of family and `sdk` token, here the LLM family and `hello`. When a pipe first calls a model whose `sdk` is `hello`, Pipelex calls the factory with four keyword arguments: the resolved model spec, the backend's configuration, the process-wide cache of SDK clients, and the reporting delegate. The hello worker needs only the first and the last. The factory imports the worker module inside its body, so discovering the plugin imports nothing heavy.++`add_model_lister` is optional. It registers the callable behind `pipelex show models`, which Pipelex awaits when you list the models of a backend whose models use the `hello` token.++## Step 3: Write the worker++`hello_llm_worker.py` holds the model itself:++```python+from pipelex.cogt.exceptions import LLMCapabilityError+from pipelex.cogt.llm.llm_job import LLMJob+from pipelex.cogt.llm.llm_worker_abstract import LLMWorkerAbstract+from pipelex.cogt.usage.token_category import TokenCategory+from pipelex.tools.typing.pydantic_utils import BaseModelTypeVar+from typing_extensions import override++HELLO_HAIKU = """Hello, World! I am+a plugin-served model — no+keys, no clouds, just code."""+++class HelloLLMWorker(LLMWorkerAbstract):+ """A deterministic LLM worker that needs no credentials: every completion is the same haiku.++ The base class owns the job lifecycle (validation, capability checks against the model spec,+ usage reporting, telemetry). A worker implements only the generation itself.+ """++ @override+ async def _gen_text(self, llm_job: LLMJob) -> str:+ completion_text = HELLO_HAIKU+ # A real worker reads the token counts from its provider's response.+ if llm_tokens_usage := llm_job.job_report.llm_tokens_usage:+ prompt_text = llm_job.llm_prompt.user_text or ""+ llm_tokens_usage.nb_tokens_by_category = {+ TokenCategory.INPUT: len(prompt_text.split()),+ TokenCategory.OUTPUT: len(completion_text.split()),+ }+ return completion_text++ @override+ async def _gen_object(+ self,+ llm_job: LLMJob,+ *,+ schema: type[BaseModelTypeVar],+ ) -> BaseModelTypeVar:+ # The model spec declares `outputs = ["text"]`, so Pipelex never routes structured+ # generation to this model. Raising keeps the worker honest if it is called directly.+ msg = f"Model '{self.inference_model.name}' does not support structured output: it only writes a haiku."+ raise LLMCapabilityError(msg)+```++`LLMWorkerAbstract` owns everything around the generation: it validates the job, checks the prompt against what the model spec says the model accepts, reports the job's usage and records its telemetry. A worker implements `_gen_text` for text and `_gen_object` for structured output. A real plugin would call its provider at the point where this one returns the haiku, and would fill the token counts from the provider's response rather than by counting words.++## Step 4: List the models (optional)++`hello_list.py` is the lister that `_list_hello_models` delegates to. The hello backend has no remote API to ask, so it prints the models declared in the backend's configuration:++```python+from pipelex.cogt.model_backends.backend import InferenceBackend+from pipelex.runtime_hub import get_console+from rich import box+from rich.table import Table+++def list_hello_models(+ *,+ sdk: str,+ backend_name: str,+ backend: InferenceBackend,+ flat: bool,+ any_listed: bool,+) -> None:+ """List the models the hello backend declares.++ There is no remote API to ask, so the lister reads the model specs declared in the+ backend's configuration file.+ """+ console = get_console()+ model_names = backend.list_model_names()++ if flat:+ if not any_listed:+ console.print("model_id,sdk,backend")+ for model_name in model_names:+ model_spec = backend.get_model_spec(model_name)+ model_id = model_spec.model_id if model_spec else model_name+ console.print(f"{model_id},{sdk},{backend_name}")+ return++ table = Table(+ title=f"Available Models for Backend '{backend_name}' (SDK: {sdk})",+ show_header=True,+ header_style="bold cyan",+ box=box.SQUARE_DOUBLE_HEAD,+ )+ table.add_column("Model ID", style="green")+ table.add_column("Model Type", style="blue")+ for model_name in model_names:+ model_spec = backend.get_model_spec(model_name)+ if model_spec is None:+ continue+ table.add_row(model_spec.model_id, model_spec.model_type)+ console.print(table)+```++A backend that cannot list its models simply registers no lister, and `pipelex show models` then reports its `sdk` as one it cannot list.++## Step 5: Declare a model served by the plugin++The plugin serves the `hello` token, but a method names a model, not a token. Three entries in your inference configuration connect the two. They go in the `inference/` directory of your Pipelex configuration: `~/.pipelex/inference/`, which `pipelex init` writes, or your project's `.pipelex/inference/` if the project has one.++First, `backends/hello.toml` declares the model `hello-1`, whose `sdk = "hello"` is the token that selects the plugin's worker factory:++```toml+[defaults]+model_type = "llm"+sdk = "hello"+thinking_mode = "none"++[hello-1]+model_id = "hello-1"+inputs = ["text"]+outputs = ["text"]+costs = { input = 0, output = 0 }+```++Then `backends.toml` gains a `hello` table, which enables the backend that `backends/hello.toml` describes. It has no API key to declare:++```toml+[hello]+display_name = "Hello (plugin example)"+enabled = true+```++Finally, `routing_profiles.toml` routes the model to that backend. The file already has a table for the profile its `active` key names, here the default `[profiles.all_pipelex_gateway]`, so add one line inside that table rather than a second copy of it, which TOML refuses:++```toml+optional_routes = { "hello-1" = "hello" }+```++An optional route applies only while its backend is enabled, so turning the `hello` backend off leaves the profile valid. If you would rather not edit the tracked `backends.toml` and `routing_profiles.toml`, the same entries can go in the personal override files beside them, each under its table's header, as [Personal overrides](../configuration/config-technical/inference-backend-config.md#personal-overrides) explains.++## Step 6: Install the plugin and check that Pipelex found it++Install the package into the environment Pipelex runs in. `uv tool install` rebuilds the tool's environment from the requirements it is given, so name Pipelex exactly as you installed it: if you installed it with provider extras, such as `"pipelex[anthropic,google]"`, repeat them here, or uv removes those providers' packages.++```bash+# Pipelex installed as a uv tool, as in Run It Yourself (repeat any extras you installed it with)+uv tool install --with-editable ./hello-inference-plugin pipelex++# Pipelex installed in a project's virtual environment+uv pip install -e ./hello-inference-plugin+```++Then check that discovery registered it, and that the backend serves its model:++```bash+pipelex plugins list # hello_inference: external, pipelex.plugins.kernel, registered+pipelex show models hello # lists hello-1+```++In `pipelex plugins list`, the plugin's row names the group it was found under and what it contributed: `inference backend llm:hello` and `model lister hello`.++## Step 7: Run a method on the plugin's model++Save this method as `hello_plugin.mthds`. It is an ordinary one-pipe method whose `model` names `hello-1`:++```toml+domain = "hello_plugin"+description = "Using a model served by an inference-backend plugin"+main_pipe = "hello_plugin"++[pipe.hello_plugin]+type = "PipeLLM"+description = "Write a haiku about Hello World."+output = "Text"+model = { model = "hello-1", temperature = 0.5 }+prompt = "Write a haiku about Hello World."+```++Run it:++```bash+pipelex run bundle hello_plugin.mthds+```++The output is the plugin's haiku. The run calls no provider: the pipe resolves `hello-1` through the routing profile to the `hello` backend, and the plugin's worker writes the answer itself.++## When the plugin is missing++To see what happens without the plugin, turn it off. Naming it in the plugin denylist of your `pipelex.toml` works however you installed it, and uninstalling the package has the same effect:++```toml+[runtime.plugins]+disabled = ["hello_inference"]+```++`pipelex plugins list` now shows the plugin as `disabled`, and running the method again fails loudly when the pipe asks for its worker:++```+No inference backend registered for sdk 'hello' in the llm family. Is its plugin installed and enabled?+```++The model configuration still resolves, since `hello-1` is still declared and routed. Only the worker factory is missing, and Pipelex says so rather than falling back to another backend. A dry run of the method still passes without the plugin, because a dry run never builds a worker.++## Going further: wrapping a real SDK++A plugin that calls a real provider does three more things inside its worker factory, all described in [Inference Backend Plugins](inference-backend-plugins.md):++- it guards its optional SDK with `require_sdk(...)`, so a missing dependency raises `MissingDependencyError` when the backend is used rather than when Pipelex starts;+- it imports that SDK inside the factory, never at the top of the plugin module;+- it builds its client through `sdk_clients.get_or_create(...)`, so repeated workers share one connection per model handle.++## Related Documentation++- [Inference Backend Plugins](inference-backend-plugins.md) - The plugin seam, the Inference SPI and its fail-loud guarantees+- [LLM Providers & Models Configuration](../configuration/config-technical/inference-backend-config.md) - Backends, model specs and routing profiles+- [Run It Yourself](../get-started/run-it-yourself.md) - Installing the Pipelex runtime on your own machinediff --git a/mkdocs.yml b/mkdocs.ymlindex 51607d915..f6d36fc24 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -100,18 +100,43 @@ plugins:'get-started/write-methods-manually.md': 'get-started/mthds-language-tutorial.md''home/2-get-started/write-methods-manually.md': 'get-started/mthds-language-tutorial.md''home/3-understand-pipelex/viewpoint.md': 'viewpoint/viewpoint.md'- 'home/4-cookbook-examples/extract-dpe.md': 'cookbook/extract-dpe.md'- 'home/4-cookbook-examples/extract-gantt.md': 'cookbook/extract-gantt.md'- 'home/4-cookbook-examples/extract-generic.md': 'cookbook/extract-generic.md'- 'home/4-cookbook-examples/extract-proof-of-purchase.md': 'cookbook/extract-proof-of-purchase.md'- 'home/4-cookbook-examples/extract-table.md': 'cookbook/extract-table.md'- 'home/4-cookbook-examples/hello-world.md': 'cookbook/hello-world.md'+ # The cookbook section became one page that links the cookbook, whose own pages now show each method.+ # Every former example page redirects to it, and the two runtime pages it held moved into the runtime's docs.+ 'home/4-cookbook-examples/extract-dpe.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/extract-gantt.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/extract-generic.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/extract-proof-of-purchase.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/extract-table.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/hello-world.md': 'cookbook/index.md''home/4-cookbook-examples/index.md': 'cookbook/index.md'- 'home/4-cookbook-examples/invoice-extractor.md': 'cookbook/extract-invoice.md'+ 'home/4-cookbook-examples/invoice-extractor.md': 'cookbook/index.md''home/4-cookbook-examples/simple-ocr.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/write-screenplay.md': 'cookbook/index.md'+ 'home/4-cookbook-examples/write-tweet.md': 'cookbook/index.md''cookbook/simple-ocr.md': 'cookbook/index.md'- 'cookbook/invoice-extractor.md': 'cookbook/extract-invoice.md'- 'home/4-cookbook-examples/write-tweet.md': 'cookbook/write-tweet.md'+ 'cookbook/invoice-extractor.md': 'cookbook/index.md'+ 'cookbook/advisory-board.md': 'cookbook/index.md'+ 'cookbook/blog-article-generator.md': 'cookbook/index.md'+ 'cookbook/design-slides.md': 'cookbook/index.md'+ 'cookbook/discord-newsletter.md': 'cookbook/index.md'+ 'cookbook/extract-dpe.md': 'cookbook/index.md'+ 'cookbook/extract-gantt.md': 'cookbook/index.md'+ 'cookbook/extract-generic.md': 'cookbook/index.md'+ 'cookbook/extract-invoice.md': 'cookbook/index.md'+ 'cookbook/extract-markdown.md': 'cookbook/index.md'+ 'cookbook/extract-proof-of-purchase.md': 'cookbook/index.md'+ 'cookbook/extract-slides.md': 'cookbook/index.md'+ 'cookbook/extract-table.md': 'cookbook/index.md'+ 'cookbook/gen-expense-data.md': 'cookbook/index.md'+ 'cookbook/gen-synthetic-data.md': 'cookbook/index.md'+ 'cookbook/generate-image.md': 'cookbook/index.md'+ 'cookbook/hello-world.md': 'cookbook/index.md'+ 'cookbook/summarize.md': 'cookbook/index.md'+ 'cookbook/validate-expense-data.md': 'cookbook/index.md'+ 'cookbook/write-screenplay.md': 'cookbook/index.md'+ 'cookbook/write-tweet.md': 'cookbook/index.md'+ 'cookbook/cv-batch-screening.md': 'get-started/cv-batch-screening.md'+ 'cookbook/using-inference-plugins.md': 'under-the-hood/writing-an-inference-plugin.md''home/5-setup/configure-ai-providers.md': 'get-started/configure-ai-providers.md''home/5-setup/gateway-models.md': 'setup/gateway-models.md''home/5-setup/index.md': 'get-started/quick-start.md'@@ -201,24 +226,8 @@ plugins:- get-started/run-it-yourself.md: "Run It Yourself"- get-started/mthds-language-tutorial.md: "The MTHDS Language Tutorial"- get-started/configure-ai-providers.md: "Configure AI Providers"- Cookbook Examples:- - cookbook/index.md: "Cookbook Overview"- - cookbook/hello-world.md: "Hello World"- - cookbook/summarize.md: "Summarize"- - cookbook/extract-generic.md: "Extract Generic Document"- - cookbook/extract-invoice.md: "Extract Invoice"- - cookbook/extract-proof-of-purchase.md: "Extract Proof of Purchase"- - cookbook/extract-dpe.md: "Extract DPE (Energy Diagnostic)"- - cookbook/extract-table.md: "Extract Table from Image"- - cookbook/extract-gantt.md: "Extract Gantt Chart"- - cookbook/extract-markdown.md: "Extract Markdown from Document"- - cookbook/extract-slides.md: "Extract Slides from Presentation"- - cookbook/cv-batch-screening.md: "CV Batch Screening"- - cookbook/design-slides.md: "Design Slides"- - cookbook/generate-image.md: "Generate Image"- - cookbook/gen-synthetic-data.md: "Generate Synthetic Data"- - cookbook/gen-expense-data.md: "Generate Expense Data with Receipts"- - cookbook/using-inference-plugins.md: "Using Inference Plugins"+ - get-started/cv-batch-screening.md: "CV Batch Screening, Step by Step"+ - cookbook/index.md: "The Pipelex Cookbook"Viewpoint:- viewpoint/viewpoint.md: "The Know-How Graph"Features:@@ -338,6 +347,7 @@ plugins:- under-the-hood/init-cli-flows.md: "Init CLI Flows"- under-the-hood/pipe-routing-and-execution.md: "Pipe Routing & Execution"- under-the-hood/inference-backend-plugins.md: "Inference Backend Plugins"+ - under-the-hood/writing-an-inference-plugin.md: "Writing an Inference Plugin"- under-the-hood/orchestrator-plugins.md: "Orchestrator Plugins"- under-the-hood/storage-provider-plugins.md: "Storage Provider Plugins"- under-the-hood/secrets-provider-plugins.md: "Secrets Provider Plugins"@@ -416,34 +426,8 @@ nav:- Run It Yourself: get-started/run-it-yourself.md- The MTHDS Language Tutorial: get-started/mthds-language-tutorial.md- Configure AI Providers: get-started/configure-ai-providers.md- - Cookbook Examples:- - Overview: cookbook/index.md- - Quick Start:- - Hello World: cookbook/hello-world.md- - Summarize: cookbook/summarize.md- - Document Extraction:- - Generic Document: cookbook/extract-generic.md- - Invoice: cookbook/extract-invoice.md- - Proof of Purchase: cookbook/extract-proof-of-purchase.md- - DPE (Energy Diagnostic): cookbook/extract-dpe.md- - Table from Image: cookbook/extract-table.md- - Gantt Chart: cookbook/extract-gantt.md- - Markdown from Document: cookbook/extract-markdown.md- - Slides from Presentation: cookbook/extract-slides.md- - CV Batch Screening: cookbook/cv-batch-screening.md- - Visual Generation:- - Design Slides: cookbook/design-slides.md- - Generate Image: cookbook/generate-image.md- - Advanced:- - Synthetic Data: cookbook/gen-synthetic-data.md- - Expense Data with Receipts: cookbook/gen-expense-data.md- - Using Inference Plugins: cookbook/using-inference-plugins.md- - Work in Progress:- - Tweet Optimizer: cookbook/write-tweet.md- - Blog Article Generator: cookbook/blog-article-generator.md- - Advisory Board: cookbook/advisory-board.md- - Discord Newsletter: cookbook/discord-newsletter.md- - Expense Validation: cookbook/validate-expense-data.md+ - CV Batch Screening, Step by Step: get-started/cv-batch-screening.md+ - The Pipelex Cookbook: cookbook/index.md- Viewpoint:- The Know-How Graph: viewpoint/viewpoint.md- Guide:@@ -596,6 +580,7 @@ nav:- Init CLI Flows: under-the-hood/init-cli-flows.md- Pipe Routing & Execution: under-the-hood/pipe-routing-and-execution.md- Inference Backend Plugins: under-the-hood/inference-backend-plugins.md+ - Writing an Inference Plugin: under-the-hood/writing-an-inference-plugin.md- Orchestrator Plugins: under-the-hood/orchestrator-plugins.md- Storage Provider Plugins: under-the-hood/storage-provider-plugins.md- Secrets Provider Plugins: under-the-hood/secrets-provider-plugins.md