Aevia

Detail for one engine-catalog object by ref: p<N>, e<N>, f<N> or m<N>. Refs come from engine_search and name objects in the connected engine database. Polymorphic on the prefix: p<N> → process, e<N> → engine product system, f<N> → flow, m<N> → LCIA method. A workspace s<N> is a different object, read with lca_get(ref='s<N>'); this tool rejects it. Process detail defaults to a summary of both sides (top 20 each: product flows first, then elementary, grouped by unit, largest amount first); section='inputs'|'outputs' with offset pages one side, and limit (max 100) sizes the page. Every heading states the true total; a follow-up hint appears whenever rows remain. include_providers=true on a flow ref lists the processes that produce it. An m<N> returns the method's categories; section='factors' adds their characterization factors (rarely needed). A process's exchange rows and reference product carry f<N> refs, which the compose and edit tools accept directly.

Search an LCA database for processes, systems, flows or methods. The database is the one named by engine, else this connection's default. kind scopes to processes, systems, flows, projects, methods (m<N> refs), or all (processes, systems and flows). query='*' (or an empty string) enumerates everything of the given kind — e.g. kind='system', query='*' lists every product system in the database (one page of limit, plus the true total). With kind='flow', flow_type (elementary / product / waste) filters the results; with kind='process', process_type (unit_process / system_process) does. Returns typed refs (p1, e1, f1; a system hit is an e<N> engine-catalog ref, not a workspace s<N>) valid for the session, accepted by engine_get and lca_run_assessment. scope_ref (any engine ref such as p3/e1/m2 from an earlier result) searches the database that ref came from instead, for comparing across databases; refs minted that way stay bound to that database.

Search the library and return abstracts with matching passages. Three modes: (1) query only → discover documents AND return each one's abstract + relevant chunk excerpts in one call; (2) document_refs only → abstract + first chunks per doc as a table-of-contents glimpse; (3) both → re-rank chunks against the query, scoped to those refs. At least one of query or document_refs is required. In query-discovery mode you may also scope by journal / year_from / year_to (ignored when document_refs is given).

Full text of one library document, by its k<N> ref. The ref comes from a recent knowledge_search (k1, k7). knowledge_get_excerpts returns abstracts and matching passages, which usually suffice; this returns the whole paper. Refs marked [ref-only] have no full text, so for those it returns the same abstract knowledge_get_excerpts does.

Search 130,000+ peer-reviewed sustainability papers and the account's uploads. Articles from Sustainability, the Journal of Cleaner Production, the International Journal of Life Cycle Assessment and the Journal of Industrial Ecology, 1993 to the present — LCA, material flows, energy, food and agriculture, materials, waste, buildings and policy. English-language; most entries are abstract and metadata only. Returns ref-numbered metadata only (title, authors, year, journal, DOI) — no abstract, no excerpts. Refs (e.g. k1, k7) persist for this session and are accepted by knowledge_get_excerpts (passages) and knowledge_get_full_document (the full paper). limit defaults to 12; a larger limit suits broad literature surveys. Optional filters: journal (its full name) and year_from / year_to.

Break down what drives an impact category. ref is a<N> (analyses a saved assessment's setup) or s<N> (analyses a saved system directly, with no prior assessment needed; method and amount then shape the solve). Returns a b<N> breakdown ref, a separate object from the a<N> it analyses. Modes: by='process' ranks contributing processes (total_amount = per-process total, loop-corrected); by='flow' ranks substance drivers by amount × CF; by='upstream' walks the supply chain. For composed (bill-of-materials) systems only process via an a<N> is available; flow, upstream and an s<N> return 422. The first call per solve prepares the engine in the background (about 3–5 s); later calls on the same solve reuse it. Rows carry p<N>/f<N> refs for further detail.

Quantify which inputs drive a system's result, and by how much. ref is a saved assessment (a<N>). Composed (bill-of-materials) systems are analysed exactly and instantly; engine-backed tornado uses one cached contribution solve, and engine sweep/scenarios re-solve openLCA param:<name> parameters. Every result states its nature, source and limits. Pass at most one study (none = default tornado): tornado: {variables?, variation_pct?} ranks each variable's ±swing; sweep: {variable, range_min, range_max, steps?, reference_ref | threshold} walks one variable (a break-even needs reference_ref or threshold); scenarios: [{name, overrides}] compares named overrides (id → multiplier). Variable ids come from a default tornado run, or a unique name fragment. member:<slug> = composed member; driver:<slug> = engine driver; param:<name> = engine parameter (sweepable); system:amount scales a whole composed system. Returns a durable v<N>, separate from the a<N> it analyses.

Apply a normalization/weighting set to a saved assessment (a<N>). ref is an a<N> in the workspace named by workspace; nw_set names one of its method's sets, and an unknown name is refused with the sets the method offers. Nothing is recalculated: the set's factors are read from the engine that calculated the assessment, and normalized and weighted results per category plus a single score are stored beside the unchanged characterized results. Applying the same set again refreshes it. A set may cover only some of the categories; the result names the ones it leaves out of the single score. lca_compare_assessments with nw_set compares assessments that all carry the same set. Weighting expresses value choices, and ISO 14044 §4.4.5 bars it from a comparative assertion disclosed to the public.

Save a comparison across 2–9 saved assessments. Each target is an a<N> ref (listable with lca_get(kind='assessments')); every lca_run_assessment call already saves one, so there is no separate save step. Two preconditions are enforced (400): all targets share one LCIA method, and all are one product at one amount unless function states the function they all deliver. Differences in allocation, database or provider linking are not refused; they are returned as equivalence warnings alongside the result. The comparison is saved into the workspace named by workspace and returned as primary_ref (c<N>), which holds the full matrix. The matrix does not rank the targets; it reports each impact category separately. nw_set adds the targets' stored single scores for that set beside the matrix; every target must already carry it (lca_apply_nw_set). The assessment_interpretation skill (load_skill) documents comparison discipline.

Build a product system as a bill of quantities of database processes. Each member's amount is sent in one call. Structure only; no LCIA runs. The assembled product is the functional unit; each member is linked to its full upstream when assessed, so the total is a full-upstream figure for the declared boundary (declared_phases), with a per-material breakdown. Takes inputs (flat) or stages (a DAG of life-cycle stages), not both. The system is validated against the database; if valid it is saved and system_ref is returned for lca_run_assessment. If invalid, the response lists errors[], missing_required[] and warnings[] and nothing is saved; a corrected call carries the complete system. dry_run: true validates without saving. A tool error, not an invalid result, means the engine is unavailable. Members are p<N> refs; UUIDs are not accepted. lca_compose_linked builds explicit supply edges instead. The product_system_authoring skill (load_skill) documents build order and common failures.

Build a product system as an explicit process network with supply edges. Every member and supply edge is sent in one call. Structure only; no LCIA runs. For a list of materials and quantities, lca_compose_assembly is simpler. A link may route a waste output to its treatment (consumer_ref outputs it, provider_ref treats it). ref_process_ref is the functional unit's process and also appears in member_process_refs. It is validated against the database; if valid it is saved and system_ref is returned for lca_run_assessment. If invalid, the response lists errors[], missing_required[] and warnings[] and nothing is saved; a corrected call carries the complete system. dry_run: true validates without saving. A tool error (not an invalid result) means the engine is unavailable. Takes p<N>/f<N> refs; UUIDs are not accepted. Requires the user's own writable engine; an unreachable member blocks the build. The product_system_authoring skill (load_skill) covers build order and failures.

Create a workspace and return the name later calls pass as workspace. The workspace is the user's own, and later calls work in it by passing that name. By default it creates a new, empty workspace and makes it the connection's default — the workspace a call naming none reads, shared by every conversation on the connection; tools that save still take workspace on every call. With adopt_sandbox: true, the default workspace, when it is a sandbox created for this connection, becomes that workspace instead: renamed to name and made an ordinary workspace, with everything already saved in it kept in place and every workspace ref still valid; a later connection starts in a new sandbox. Either way the workspace counts toward the account's workspace limit and appears in the Aevia app. A name the user already has is refused rather than reused; an existing workspace is used by passing its name as workspace. goal_statement records the study's goal (ISO 14040 §4.2).

Delete a saved system, assessment, comparison, analysis or report. ref is an s<N> system, a<N> assessment, c<N> comparison, b<N> contribution analysis, v<N> sensitivity analysis or r<N> report in the workspace named by workspace. The deletion cannot be undone. A system takes its assessments with it; they leave any comparison they belong to. An assessment leaves its system, its comparisons and its analyses (kept, detached). A comparison takes only itself. Reports citing a deleted object are kept, but those citations stop resolving. Without confirm: true the call returns a preview listing what goes by ref, and deletes nothing. For an s<N>, its copy in the openLCA engine is kept unless delete_engine_copy: true, which deletes it only when Aevia created it and the engine is writable; that changes the openLCA database, so it needs the Execute access level. A process or flow authored into an engine is deleted by engine_delete.

Patch a saved composed (bill-of-materials) system (s<N>). Ops: replace_provider (swap a member everywhere it is used), set_target_amount (rescale the functional unit), set_title (rename), add_member / remove_member, set_member_amount (rescale an existing member), add_stage / remove_stage (grow or shrink the stage DAG; it must stay acyclic with one sink), set_boundary (declared_phases / excluded_phases; nothing goes stale). mode (default edit): edit patches in place, keeping the same s<N>; fork derives a new s<M>. A mirror is forked when content changes, with a warning. Each member is linked cradle-to-gate independently when assessed, so swaps and additions bring their own background; only unit compatibility is checked, so a swap can change a dataset's geography, technology and reference year. Members are p<N> refs; UUIDs are not accepted. Linked and single-process systems are edited with lca_edit_linked. The returned ref can be assessed with lca_run_assessment.

Patch a saved linked or single-process system (s<N>). A linked system is an explicit process network. Graph ops: add_link (wire a supplier onto a consumer input, or a waste output onto its treatment; the provider joins automatically), remove_link (drop matching edges; orphans are pruned), rewire_link (repoint one edge). Also replace_provider (swap a supplier on every edge it feeds; a bare unit_process swap warns: its background is unwired), set_target_amount, set_title and set_boundary (phases only). A swap checks units only; geography, technology and vintage can change. lca_get(ref='s<N>', form='authored') shows every edge and the consumer_input_index needed when a consumer has one flow on several exchanges. A link's amount only validates. mode edit (default) patches in place; fork derives a new s<M>; a mirror forks on a content change. A single-process system takes only the setters. Composed systems use lca_edit_assembly. Takes p<N>/f<N> refs; UUIDs are not accepted.

Read a saved workspace object by ref, or list systems, results or workspaces. Takes exactly one of ref (one object's detail) or kind (a list). A ref is read in the workspace named by workspace, which it requires: each workspace numbers its objects from 1. A kind list reads that workspace, else this connection's default. Refs: s/a/c/b/v/r<N> → system / assessment / comparison / contribution analysis / sensitivity analysis / report. An s<N> read also states the system's kind and its edit tool; form='authored' returns the authored shape the compose and edit tools accept. Kinds: 'systems' / 'assessments' / 'comparisons' / 'contribution_analyses' / 'sensitivity_analyses' / 'reports' return paginated lists of this workspace (filters: query, system_ref, method, assessment_status); 'workspaces' / 'engines' list those available, marking the default. UUIDs are not accepted.

Poll a long-running call that returned a task_id instead of a result. Takes that id and waits up to 45 seconds for the task to finish. Returns status: 'pending' (still running after that wait; calling again waits again), 'success' (result holds the tool's result text and its ref; the saved object is read with lca_get) or 'error' (with can_retry). Only calls that returned a task_id have one; a tool that returned its result directly has nothing to poll. A task_id is readable only by the session that started it, and only for a day.

Import an openLCA project: assess each variant and save one comparison. project is the project's name as engine_search(kind='project') lists it, or a unique part of it, in the database named by engine, else this connection's default, which must be writable. Each enabled variant's product system is imported into workspace as an s<N> (one already there is refreshed) and assessed once as an a<N> with the variant's amount, unit and allocation and the project's method and normalization/weighting set; the variants are saved as one comparison c<N>, returned as primary_ref. openLCA's API cannot calculate a project; this reproduces it variant by variant, each at its own amount (functional equivalence is not checked). Without confirm: true the call returns a preview and starts nothing. A run within 45 seconds returns its result; a longer one returns a task_id for lca_get_task_status. Refused: fewer than 2 or more than 9 enabled variants, or parameter redefinitions. Disabled variants are skipped.

Import an engine product system (e<N>) into a workspace as a saved system. The e<N> from engine_search is imported from its own database; the saved copy gets a stable s<N>. Captures the system's full definition server-side (no need to read its graph) and mirrors it — the copy tracks the engine original for drift and is immediately assessable (lca_run_assessment s<N>) and comparable. Idempotent: re-importing the same engine system returns the existing s<N>. Only accepts e<N> (engine systems) — a workspace s<N> is already imported, and a process p<N> is not a system. To RESTRUCTURE it: read lca_get(ref='s<N>', form='authored'), then either targeted lca_edit_linked ops (add_link/remove_link/rewire_link/replace_provider/set_target_amount/set_title — a new version of the same s<N>) or lca_compose_linked (a new s<M> from the restructured topology). The mirror stays fully assessable/comparable. On this rail lca_edit_linked also needs the base_version_seq lca_get reports.

Run LCIA on a target and save the result as a durable assessment (a<N>). ref is a saved workspace system (s<N>), or an engine-catalog process (p<N>) or system (e<N>) from engine_search; it is calculated on the database it belongs to. Runs the calculation with the given parameters and returns the impact result; a run that finishes within 45 seconds returns its result directly, and a longer one returns a task_id for lca_get_task_status; the assessment is always saved into the workspace named by workspace, with no separate save step. A catalog e<N> is assessed as a one-off result and not imported as a tracked system (lca_import_system does that). nw_set names one of the method's normalization/weighting sets, applied after the calculation for a single score. lca_analyze_contributions breaks a result down. The assessment_interpretation skill (load_skill) documents what a result means and comparison discipline.

Set this connection's default engine database. The default is the database browsing and composing use when a call names no engine. The default is shared by every conversation on the connection. name is the engine name as shown, matched case-insensitively (a code span, accepted with or without its backticks). Nothing saved moves: no s<N>/a<N>/c<N>/b<N>/v<N> ref is affected, and saved systems keep solving on their own engine. Catalog refs (p<N>, e<N>, f<N>, m<N>) stay bound to the database that minted them: reading one still works, since engine_get and lca_run_assessment follow the ref back to its own database, but lca_compose_* and lca_edit_* refuse a member ref from another database, so members for a new system come from searches run after the switch.

Set this connection's default workspace. The default is the workspace a call that names no workspace reads. name is the workspace name as lca_get(kind='workspaces') shows it (a code span; backticks optional). The default is shared by every conversation on the connection, so another conversation can move it too; tools that save take workspace on every call and are unaffected by it. Workspace refs (s<N>, a<N>, c<N>, b<N>, v<N>) are per-workspace ordinals, so on a call naming no workspace the same number now names an object in the new default; each still names its own object on a call that names its workspace. Engine-catalog refs (p<N>, e<N>, f<N>, m<N>) are unaffected.

How this Aevia connection works, plus playbooks for results, reports, systems. Returns a skill's playbook as the result; takes no action itself. A playbook is step-by-step guidance for a multi-step job, too long for a description. connector_guide covers how this connection works: workspaces, refs, finding data, the library, building, calculating and failures. assessment_interpretation covers reading and comparing results: what an indicator result is and is not, a figure's anchors, functional-unit equivalence and comparison discipline. report_writing covers writing results up as a document, from a screening note to an ISO 14044 study. product_system_authoring covers building a new product system with lca_compose_assembly / lca_compose_linked: build order, which of the two fits, failure modes, and tagging life-cycle phases. A loaded playbook stays in context; one load per session suffices. Skills are gated on what the token can call; an unavailable request returns the available list.