Upload packaged project bundle

README.md

@@ -1,3 +1,303 @@
----
-license: apache-2.0
----
+# BioPacific MIP Research Assistant
+
+BioPacific MIP Research Assistant is an agentic AI system designed to help researchers explore and understand scientific literature more efficiently. It combines a local LLM service, an embedding model, a Qdrant vector database, and an automated paper-processing pipeline to support paper-grounded question answering over the BioPacific literature collection.
+
+The system can ingest papers, update the searchable database, retrieve relevant documents, and serve a session-based REST API for interactive research workflows.
+
+## New Features
+
+The current version introduces several improvements for a more practical research assistant experience.
+
+- **Multi-turn conversation support.** The agent now supports session-based conversations, so users can ask follow-up questions while preserving the context of previous turns.
+- **Automatic intention recognition.** The agent can decide whether a user message actually needs retrieval. For example, it can skip retrieval for simple follow-up requests such as rephrasing, but perform retrieval when the question requires scientific evidence.
+- **Automatic natural-language filters.** The agent can infer structured retrieval constraints directly from user language, including journal, time range, and author hints. For example, if a user asks for *synthetic biology papers published in PNAS in the last 4 years*, the system can translate that request into targeted retrieval filters automatically.
+- **More concise and precise answers.** Before generating the final response, the agent first cleans and compresses retrieved paper content into focused summaries, then answers based on those refined inputs. This makes the final output shorter, clearer, and more relevant to the user's request.
+
+## Environment Setup
+
+This project requires an **Anaconda/Conda** environment.
+
+From the repository root, run:
+
+```bash
+bash install_env.sh
+```
+
+This script will automatically create a Conda environment named `biopacific` and install the required packages for the project.
+
+After the environment is created, go to the `models/` directory. Each model folder contains its own `download_model.sh` script. Run those scripts to download the required local models:
+
+```bash
+cd models/Qwen3-Embedding-8B
+bash download_model.sh
+
+cd ../Qwen3.5-9B
+bash download_model.sh
+```
+
+After that, activate the environment when you want to use the system:
+
+```bash
+conda activate biopacific
+```
+
+## Configuration
+
+After installing the environment, configure the project by editing `config.yaml`.
+
+Most settings in `config.yaml` do not need to be changed for normal use. In practice, the most important items are:
+
+- **GPU allocation**
+- **Port allocation**
+
+### GPU Allocation
+
+The two vLLM services are configured independently:
+
+- `embedding.gpu`: GPU used by the embedding model
+- `llm.gpu`: GPU used by the chat/completions model
+
+By default, the config assigns:
+
+- `embedding.gpu: "0"`
+- `llm.gpu: "1"`
+
+If your machine has at least two GPUs, this is a good default because the embedding model and the chat model can run separately. If you only have one GPU, you will need to adjust the configuration carefully based on available memory and your deployment strategy.
+
+You may also need to tune:
+
+- `embedding.gpu_memory_utilization`
+- `llm.gpu_memory_utilization`
+- `embedding.max_model_len`
+- `llm.max_model_len`
+
+If you encounter out-of-memory issues, reducing the memory utilization value is usually the first thing to try.
+
+### Port Allocation
+
+The default service layout is:
+
+- `embedding.port: 7770`
+- `llm.port: 7771`
+- `qdrant.port: 7772`
+- `pipeline.s5_agent.service_port: 7773`
+
+Make sure these ports are free on your machine before starting the system. If any of them conflict with another service, update the values in `config.yaml`.
+
+## Running the System
+
+Once the `biopacific` environment is ready and `config.yaml` has been configured, start the system from the repository root:
+
+```bash
+conda activate biopacific
+cd /path/to/BioPacific-MIP-Rearch-Assistant
+./start_service.sh
+```
+
+This command automatically starts the following long-running services:
+
+- `embedding`: vLLM embedding server
+- `llm`: vLLM chat/completions server
+- `qdrant`: vector database
+- `agent`: paper agent REST service
+
+The startup workflow also runs the data pipeline automatically:
+
+1. It checks and starts the prerequisite services.
+2. It runs the paper pipeline stages.
+3. It updates the paper database if new content is available.
+4. It finally starts the agent REST service.
+
+After the agent service is running, the system is ready to be accessed through the REST API.
+
+### Common Commands
+
+Start everything:
+
+```bash
+./start_service.sh
+```
+
+Stop everything:
+
+```bash
+./start_service.sh stop
+```
+
+Restart everything:
+
+```bash
+./start_service.sh restart
+```
+
+Check service status:
+
+```bash
+./start_service.sh status
+```
+
+If you want the paper database to refresh regularly, you can schedule a monthly restart:
+
+```bash
+./start_service.sh restart
+```
+
+Running this periodically is useful because each restart will trigger the automated pipeline and allow the database to update when new papers are available.
+
+## REST API Usage
+
+An example client is provided in `rest-api/example_chat_session.py`.
+
+You can run it directly after the services are up:
+
+```bash
+python rest-api/example_chat_session.py
+```
+
+### Session ID and Multi-turn Conversation
+
+The REST API is session-based. A `sessionId` identifies one conversation on the server side.
+
+If you keep using the same `sessionId`, the agent will preserve recent conversation history and support multi-turn follow-up questions. This is what enables interactions such as:
+
+- asking an initial literature question
+- following up with "tell me more about paper [2]"
+- requesting a simpler explanation of the previous answer
+
+If you start a new `sessionId`, the server treats it as a new conversation.
+
+### The Three Core Methods
+
+The API provides three main endpoints:
+
+#### 1. Start a Session
+
+`POST /v1/session/start`
+
+Example request body:
+
+```json
+{
+  "sessionId": "optional-session-id"
+}
+```
+
+Example response:
+
+```json
+{
+  "sessionId": "your-session-id"
+}
+```
+
+If you do not want to manage session IDs yourself, the example client can generate one automatically.
+
+#### 2. Chat
+
+`POST /v1/chat`
+
+Example request body:
+
+```json
+{
+  "sessionId": "your-session-id",
+  "message": "Find synthetic biology papers published in PNAS in the last 4 years."
+}
+```
+
+Example response shape:
+
+```json
+{
+  "sessionId": "your-session-id",
+  "response": "Final grounded answer...",
+  "docs": [
+    {
+      "chat_doc_id": 1,
+      "rank": 1,
+      "score": 0.91,
+      "paper": {
+        "title": "...",
+        "authors": ["..."],
+        "journal": "...",
+        "pub_date": "...",
+        "doi": "...",
+        "keywords": ["..."],
+        "abstract": "...",
+        "sections": [
+          {
+            "section_title": "...",
+            "subsections": [
+              {
+                "title": "...",
+                "paragraphs": ["..."]
+              }
+            ]
+          }
+        ],
+        "link": "https://pubmed.ncbi.nlm.nih.gov/..."
+      }
+    }
+  ]
+}
+```
+
+The `response` field contains the assistant answer, and `docs` contains the retrieved paper results for that turn. Each document entry currently includes:
+
+- `chat_doc_id`: the stable paper identifier used by the assistant for inline citations during the chat session
+- `rank`: the retrieval ranking for the current turn
+- `score`: the retrieval similarity score returned by the agent
+- `paper`: the paper payload, including `title`, `abstract`, `sections`, `authors`, `journal`, `pub_date`, `doi`, `keywords`, and a PubMed `link`
+
+Important: citations in the agent's `response` refer to `chat_doc_id`, not to `rank`. For example, if the response cites paper `[3]`, that means the cited paper is the one whose `chat_doc_id` is `3`, not necessarily the paper whose retrieval `rank` is `3` in the current turn.
+
+#### 3. End a Session
+
+`POST /v1/session/end`
+
+Example request body:
+
+```json
+{
+  "sessionId": "your-session-id"
+}
+```
+
+Example response:
+
+```json
+{
+  "ok": true
+}
+```
+
+Ending a session clears the conversation state associated with that session on the server.
+
+### Example Python Workflow
+
+The example client exposes three corresponding methods:
+
+- `start_session()`
+- `chat()`
+- `end_session()`
+
+A typical workflow looks like this:
+
+```python
+from example_chat_session import ExampleChatSession
+
+session = ExampleChatSession()
+session.start_session()
+
+session.chat("Find synthetic biology papers published in PNAS in the last 4 years.")
+session.chat("Now summarize the key trends from those papers.")
+session.chat("Please explain the previous answer in simpler language.")
+
+session.end_session()
+```
+
+As long as the same session remains active, the assistant can use the conversation history to interpret follow-up questions more effectively.
+
+## Summary
+
+BioPacific MIP Research Assistant provides an agentic, paper-grounded research workflow with automated paper ingestion, retrieval, summarization, and session-based conversation. With the latest updates, it now supports better multi-turn interaction, smarter retrieval decisions, more precise natural-language filtering, and cleaner final answers for literature exploration.

config.yaml

@@ -0,0 +1,136 @@
+# ============================================================================
+# BioPacific service config. Single source of truth for ports, GPU assignment,
+# model paths, memory budgets, and paper-search agent options.
+# ./start_service.sh reads this file on every invocation; edit and re-run.
+#
+# Paths are resolved relative to the repository root (the directory that
+# contains this file). Absolute paths are accepted too.
+#
+# Service port layout:
+#   embedding  (Qwen3-Embedding-8B) : 7770
+#   llm        (Qwen3.5-9B)         : 7771
+#   qdrant     (vector DB)          : 7772
+#   agent      (paper agent HTTP)   : 7773
+# ============================================================================
+
+# ----------------------------------------------------------------------------
+# Global settings
+# ----------------------------------------------------------------------------
+
+env_name: biopacific        # conda env name to auto-detect for python / vllm
+service_host: 0.0.0.0       # vLLM + Qdrant HTTP listen address
+
+# ----------------------------------------------------------------------------
+# Qdrant vector database
+# ----------------------------------------------------------------------------
+qdrant:
+  binary: pipeline/s4-embedding/qdrant/qdrant    # path to the qdrant executable
+  storage_path: pipeline/s4-embedding/vectors    # on-disk location of indexed vectors
+  port: 7772                                     # HTTP port
+
+# ----------------------------------------------------------------------------
+# Qwen3-Embedding-8B (embedding model, vLLM)
+#
+# Turns text into number vectors for search. Clients call this server on
+# `port` below; only embeddings are served (no chat here).
+# ----------------------------------------------------------------------------
+embedding:
+  served_name: Qwen3-Embedding-8B
+  model_dir: models/Qwen3-Embedding-8B
+  # TCP port this embedding HTTP server listens on (must match other services).
+  port: 7770
+  # Which GPU(s) to use: "0" = first GPU. Use "0,1" only if you run multi-GPU
+  # tensor parallel and your start script expects several devices.
+  gpu: "0"
+  # Fraction of GPU VRAM vLLM may reserve (0.0–1.0). Lower if you run out of memory.
+  gpu_memory_utilization: 0.8
+  # Max input length in tokens for one embedding request; raise only if you need
+  # longer texts and your GPU has enough memory.
+  max_model_len: 32767
+
+# ----------------------------------------------------------------------------
+# Qwen3.5-9B (chat / completions LLM, vLLM)
+#
+# One model for parsing queries, refining snippets, and writing answers. Same
+# OpenAI-style HTTP API as typical chat APIs. Tune sampling below for more or
+# less randomness in replies.
+# ----------------------------------------------------------------------------
+llm:
+  served_name: llm
+  model_dir: models/Qwen3.5-9B
+  # TCP port for this LLM HTTP server (different from embedding and Qdrant).
+  port: 7771
+  # GPU index for this server, e.g. "1" = second GPU. Use a free GPU not used by embedding.
+  gpu: "1"
+  # How much of that GPU’s VRAM vLLM may use; reduce if you hit out-of-memory errors.
+  gpu_memory_utilization: 0.8
+  # Randomness: higher = more creative / less repeatable; lower = steadier answers.
+  temperature: 0.6
+  # Caps how adventurous word choices can be (0–1). Near 1 = broader; lower = more focused.
+  top_p: 0.9
+  # Hard cap on how many new tokens the model may generate in one reply (not input length).
+  max_tokens: 4096
+  # Max context window (prompt + history + new text) in tokens; required by ./start_service.sh.
+  max_model_len: 65536
+
+pipeline:
+  # Stage 1: download PubMed metadata and abstracts, grouped by journal.
+  s1_index:
+    start_year: 2000                # First publication year to include.
+    end_year: current               # Last year to include; "current" means this calendar year.
+    max_retries: 3                  # Retry a whole journal this many times if the indexing run fails.
+    retry_wait_seconds: 60          # Wait this many seconds between those journal-level retries.
+    ncbi_api_key: "67f60f7a3eb8692d7a03168cb753b4271808"  # Optional PubMed API key; allows faster requests.
+    output_dir: pipeline/s1-index   # Where one JSON file per journal is written.
+    journals:                       # Output name -> journal ISSN used in PubMed.
+      nature: "0028-0836"
+      nature_communications: "2041-1723"
+      pnas: "0027-8424"
+      acs_synthetic_biology: "2161-5063"
+  # Stage 2: keep only papers relevant to the topic below.
+  s2_filter:
+    input_dir: pipeline/s1-index    # Reads the per-journal JSON files from s1_index.
+    output_dir: pipeline/s2-filter  # Writes filtered results here.
+    keyword: "synthetic biology"    # Topic used to decide whether a paper is relevant.
+    batch_size: 16                  # Max concurrent model API calls during filtering.
+    api_endpoint: "https://api.fireworks.ai/inference/v1"  # OpenAI-compatible API base URL.
+    api_key: "utKx5V7ovmjcL62G2j0sbSC8JDAnRGkmZf35IRBBAMs5Ofse"  # API key for that service.
+    model: "accounts/fireworks/models/qwen3-vl-30b-a3b-instruct"  # Model used for yes/no relevance checks.
+    direct_copy_journals:           # Journals to keep without LLM filtering.
+      - acs_synthetic_biology
+    filter_journals:                # Journals that should go through the LLM filter.
+      - nature
+      - nature_communications
+      - pnas
+  # Stage 3: fetch full text sections when possible; otherwise keep abstracts only.
+  s3_fetch:
+    input_dir: pipeline/s2-filter   # Reads relevant-paper JSON files from s2_filter.
+    output_dir: pipeline/s3-fetch   # Writes fetched/enriched paper JSON files here.
+    fetch_interval: 1               # Minimum seconds per paper; helps avoid hitting sites too fast.
+    checkpoint_interval: 50         # Save resume progress after this many processed papers.
+    timeout: 90                     # Per-paper timeout for DOI lookup, HTTP fetch, and browser fallback.
+    abstract_only_journals:         # Journals that should skip full-text fetching and stay abstract-only.
+      - acs_synthetic_biology
+    fetch_journals:                 # Journals where DOI/full-text fetching should run.
+      - nature
+      - nature_communications
+      - pnas
+  # Stage 4: turn fetched papers into vectors and store them in Qdrant.
+  s4_embedding:
+    input_dir: pipeline/s3-fetch    # Reads fetched journal JSON files from s3_fetch.
+    papers_dir: pipeline/s4-embedding/papers  # Stores one normalized JSON file per paper (PMID.json).
+    manifest_path: pipeline/s4-embedding/paper-embedding-manifest.json  # Local state for incremental re-indexing.
+    collection: papers              # Qdrant collection name to create/update.
+    batch_size: 32                  # Papers per embedding + Qdrant upsert batch.
+    timeout: 300                    # Timeout for embedding API and Qdrant requests.
+    embedding_model: Qwen3-Embedding-8B  # Model name sent to the embeddings server.
+    preprocess_limit: null          # Optional cap for preprocessing this run; null means no limit.
+    index_limit: null               # Optional cap for indexing new/changed papers this run; null means no limit.
+  # Stage 5: chat service that searches papers and answers with paper-grounded summaries.
+  s5_agent:
+    enhanced_query: true            # true = parse the question into filters + search text; false = plain vector search only.
+    top_k: 5                        # Default number of papers retrieved for each user question.
+    collection: papers              # Qdrant collection the agent searches.
+    timeout_seconds: 30.0           # HTTP timeout for retrieval and LLM calls inside the agent.
+    history_turns: 5                # How many recent chat turns each session keeps in memory. Increase this value will slow down the response time and might cause error if exceeds the max tokens of the model.
+    service_port: 7773              # Port for the paper-agent REST API.

install_env.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ENV_NAME="${ENV_NAME:-biopacific}"
+PYTHON_VERSION="${PYTHON_VERSION:-3.12}"
+
+if ! command -v conda >/dev/null 2>&1; then
+    echo "conda is not available in PATH." >&2
+    exit 1
+fi
+
+if [[ "$(uname -s)" != "Linux" ]]; then
+    echo "This installer currently supports Linux only." >&2
+    exit 1
+fi
+
+CONDA_BASE="$(conda info --base)"
+source "${CONDA_BASE}/etc/profile.d/conda.sh"
+
+if conda env list | awk '{print $1}' | grep -Fxq "${ENV_NAME}"; then
+    echo "Conda environment '${ENV_NAME}' already exists. Reusing it."
+else
+    echo "Creating conda environment '${ENV_NAME}' with Python ${PYTHON_VERSION} ..."
+    conda create -n "${ENV_NAME}" "python=${PYTHON_VERSION}" -y
+fi
+
+conda activate "${ENV_NAME}"
+
+ARCH="$(uname -m)"
+HOST_TRIPLE=""
+SYSROOT_PACKAGE=""
+case "${ARCH}" in
+    x86_64|amd64)
+        HOST_TRIPLE="x86_64-conda-linux-gnu"
+        SYSROOT_PACKAGE="sysroot_linux-64"
+        ;;
+    aarch64|arm64)
+        HOST_TRIPLE="aarch64-conda-linux-gnu"
+        SYSROOT_PACKAGE="sysroot_linux-aarch64"
+        ;;
+    *)
+        echo "Unsupported Linux architecture: ${ARCH}" >&2
+        exit 1
+        ;;
+esac
+
+echo "Installing conda-forge compiler toolchain and sysroot into '${ENV_NAME}' ..."
+conda install -n "${ENV_NAME}" -c conda-forge -y \
+    compilers \
+    c-compiler \
+    cxx-compiler \
+    binutils \
+    libgcc-ng \
+    libstdcxx-ng \
+    "${SYSROOT_PACKAGE}"
+
+# Reactivate so newly installed compiler activation hooks take effect.
+conda deactivate
+conda activate "${ENV_NAME}"
+
+export PATH="${CONDA_PREFIX}/bin:${PATH}"
+
+CC_CANDIDATE="${CONDA_PREFIX}/bin/${HOST_TRIPLE}-cc"
+CXX_CANDIDATE="${CONDA_PREFIX}/bin/${HOST_TRIPLE}-c++"
+
+if [[ -x "${CC_CANDIDATE}" ]]; then
+    export CC="${CC_CANDIDATE}"
+elif command -v "${HOST_TRIPLE}-cc" >/dev/null 2>&1; then
+    export CC="$(command -v "${HOST_TRIPLE}-cc")"
+fi
+
+if [[ -x "${CXX_CANDIDATE}" ]]; then
+    export CXX="${CXX_CANDIDATE}"
+elif command -v "${HOST_TRIPLE}-c++" >/dev/null 2>&1; then
+    export CXX="$(command -v "${HOST_TRIPLE}-c++")"
+fi
+
+if [[ -z "${CC:-}" || -z "${CXX:-}" ]]; then
+    echo "Failed to locate conda compiler toolchain after installation." >&2
+    exit 1
+fi
+
+if [[ -d "${CONDA_PREFIX}/${HOST_TRIPLE}/sysroot" ]]; then
+    export CONDA_BUILD_SYSROOT="${CONDA_PREFIX}/${HOST_TRIPLE}/sysroot"
+fi
+
+export CMAKE_C_COMPILER="${CC}"
+export CMAKE_CXX_COMPILER="${CXX}"
+export CUDAHOSTCXX="${CXX}"
+export CMAKE_CUDA_HOST_COMPILER="${CXX}"
+export CCACHE_DISABLE=1
+
+echo "Installing uv into '${ENV_NAME}' ..."
+python -m pip install --upgrade pip
+python -m pip install uv
+
+echo "Installing core Python packages with uv ..."
+uv pip install -U \
+    requests \
+    openai \
+    beautifulsoup4 \
+    selenium \
+    webdriver-manager \
+    numpy
+
+echo "Installing vLLM with uv ..."
+if ! uv pip install -U vllm --torch-backend=auto; then
+    echo >&2
+    echo "vLLM installation failed." >&2
+    echo "Diagnostics:" >&2
+    echo "  gcc: $(command -v gcc || true)" >&2
+    echo "  g++: $(command -v g++ || true)" >&2
+    echo "  CC: ${CC:-"(unset)"}" >&2
+    echo "  CXX: ${CXX:-"(unset)"}" >&2
+    echo "  CMAKE_C_COMPILER: ${CMAKE_C_COMPILER:-"(unset)"}" >&2
+    echo "  CMAKE_CXX_COMPILER: ${CMAKE_CXX_COMPILER:-"(unset)"}" >&2
+    echo "  CUDAHOSTCXX: ${CUDAHOSTCXX:-"(unset)"}" >&2
+    echo "  sysroot: ${CONDA_BUILD_SYSROOT:-"(unset)"}" >&2
+    echo "  gcc version: $(${CC} --version 2>/dev/null | sed -n '1p' || true)" >&2
+    echo "  g++ version: $(${CXX} --version 2>/dev/null | sed -n '1p' || true)" >&2
+    exit 1
+fi
+
+echo
+echo "Environment ready."
+echo "  active env: ${ENV_NAME}"
+echo "  arch: ${ARCH}"
+echo "  python: $(python --version 2>&1)"
+echo "  uv: $(uv --version 2>&1)"
+echo "  gcc: $(command -v gcc)"
+echo "  g++: $(command -v g++)"
+if [[ -n "${CC:-}" ]]; then
+    echo "  CC: ${CC}"
+fi
+if [[ -n "${CXX:-}" ]]; then
+    echo "  CXX: ${CXX}"
+fi
+if [[ -n "${CONDA_BUILD_SYSROOT:-}" ]]; then
+    echo "  CONDA_BUILD_SYSROOT: ${CONDA_BUILD_SYSROOT}"
+fi

src.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1e15d9c61600d5ff851b636c9c01fcea7a2b57822578611e9e6ddfa97424c16
+size 1090877934

start_service.sh

@@ -0,0 +1,806 @@
+#!/usr/bin/env bash
+#
+# BioPacific launcher and orchestrator.
+#
+# This script manages two different concepts:
+#
+# 1. Services (long-running background processes)
+#    - embedding : vLLM embedding server
+#    - llm       : vLLM chat/completions server
+#    - qdrant    : vector database
+#    - agent     : paper agent REST service
+#
+# 2. Pipeline stages (one-shot foreground jobs)
+#    - s1_index     : build journal article indexes
+#    - s2_filter    : filter indexed papers
+#    - s3_fetch     : fetch article content / sections
+#    - s4_embedding : preprocess and push embeddings into Qdrant
+#
+# Default orchestration:
+#   start / restart with no explicit targets performs a full bring-up:
+#     1) start embedding + llm + qdrant
+#     2) wait until those prerequisite services are ready
+#     3) run pipeline.s1_index -> s2_filter -> s3_fetch -> s4_embedding
+#     4) start the agent service
+#
+# Service processes run in the background via nohup; PIDs are recorded under
+# logs/ so subsequent stop/status calls can find them again. Pipeline stages
+# run in the foreground and stream output to both the terminal and log files.
+#
+# Common usage:
+#   ./start_service.sh
+#   ./start_service.sh start
+#   ./start_service.sh start embedding llm qdrant
+#   ./start_service.sh stop
+#   ./start_service.sh stop agent
+#   ./start_service.sh restart
+#   ./start_service.sh status
+#   ./start_service.sh pipeline
+#   ./start_service.sh pipeline s2_filter s3_fetch
+#   CONFIG_FILE=/path/to/config.yaml ./start_service.sh start
+
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_FILE="${CONFIG_FILE:-${ROOT_DIR}/config.yaml}"
+LOG_DIR="${LOG_DIR:-${ROOT_DIR}/logs}"
+mkdir -p "${LOG_DIR}"
+
+SERVICES=(embedding llm qdrant agent)
+PIPELINE_STAGES=(s1_index s2_filter s3_fetch s4_embedding)
+PREREQ_SERVICES=(embedding llm qdrant)
+STOP_ORDER=(agent qdrant llm embedding)
+
+PYTHON_BIN=""
+VLLM_BIN=""
+CONDA_ENV_DIR=""
+
+# ---------------------------------------------------------------------------
+# Tiny helpers
+# ---------------------------------------------------------------------------
+
+die() {
+  echo "$*" >&2
+  exit 1
+}
+
+require_executable() {
+  local executable="$1"
+  local label="$2"
+  if [[ -z "${executable}" || ! -x "${executable}" ]]; then
+    die "Missing executable: ${label}"
+  fi
+}
+
+require_dir() {
+  [[ -d "$1" ]] || die "Directory not found: $1"
+}
+
+require_file() {
+  [[ -f "$1" ]] || die "File not found: $1"
+}
+
+append_unique_path() {
+  local value="$1"
+  local current="$2"
+  if [[ -z "${current}" ]]; then
+    printf '%s' "${value}"
+  elif [[ ":${current}:" == *":${value}:"* ]]; then
+    printf '%s' "${current}"
+  else
+    printf '%s:%s' "${value}" "${current}"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+# Conda env auto-detection (same behavior as before)
+# ---------------------------------------------------------------------------
+
+detect_conda_env_dir() {
+  local env_name="$1"
+  local -a candidates=()
+
+  if [[ -n "${PREFERRED_ENV_DIR:-}" ]]; then
+    candidates+=("${PREFERRED_ENV_DIR}")
+  fi
+  if [[ -n "${CONDA_PREFIX:-}" && "$(basename "${CONDA_PREFIX}")" == "${env_name}" ]]; then
+    candidates+=("${CONDA_PREFIX}")
+  fi
+  candidates+=("${ROOT_DIR}/../anaconda/envs/${env_name}")
+  if command -v conda >/dev/null 2>&1; then
+    local conda_base
+    conda_base="$(conda info --base 2>/dev/null || true)"
+    [[ -n "${conda_base}" ]] && candidates+=("${conda_base}/envs/${env_name}")
+  fi
+  candidates+=(
+    "${HOME}/anaconda/envs/${env_name}"
+    "${HOME}/miniconda3/envs/${env_name}"
+    "${HOME}/mambaforge/envs/${env_name}"
+  )
+  for candidate in "${candidates[@]}"; do
+    if [[ -n "${candidate}" && -x "${candidate}/bin/python" ]]; then
+      printf '%s\n' "${candidate}"
+      return 0
+    fi
+  done
+  return 1
+}
+
+use_preferred_runtime() {
+  local env_name="$1"
+  local env_dir
+  env_dir="$(detect_conda_env_dir "${env_name}" || true)"
+
+  if [[ -n "${env_dir}" ]]; then
+    CONDA_ENV_DIR="${env_dir}"
+    export PATH
+    PATH="$(append_unique_path "${CONDA_ENV_DIR}/bin" "${PATH}")"
+    export LD_LIBRARY_PATH
+    LD_LIBRARY_PATH="$(append_unique_path "${CONDA_ENV_DIR}/lib" "${LD_LIBRARY_PATH:-}")"
+    export LIBRARY_PATH
+    LIBRARY_PATH="$(append_unique_path "${CONDA_ENV_DIR}/lib" "${LIBRARY_PATH:-}")"
+    export CONDA_PREFIX="${CONDA_ENV_DIR}"
+    export CONDA_DEFAULT_ENV="${env_name}"
+    PYTHON_BIN="${CONDA_ENV_DIR}/bin/python"
+    VLLM_BIN="${CONDA_ENV_DIR}/bin/vllm"
+  fi
+  [[ -z "${PYTHON_BIN}" ]] && PYTHON_BIN="$(command -v python3 || true)"
+  [[ -z "${VLLM_BIN}"  ]] && VLLM_BIN="$(command -v vllm || true)"
+  require_executable "${PYTHON_BIN}" "python3"
+}
+
+# ---------------------------------------------------------------------------
+# Config loading via PyYAML. Emits shell assignments for CFG_* variables.
+# ---------------------------------------------------------------------------
+
+load_config() {
+  require_file "${CONFIG_FILE}"
+  local dump
+  dump="$(
+    ROOT_DIR="${ROOT_DIR}" \
+    CONFIG_FILE="${CONFIG_FILE}" \
+    "${PYTHON_BIN}" - <<'PY'
+import os, shlex, sys
+try:
+    import yaml
+except ImportError:
+    sys.stderr.write(
+        "PyYAML is required. Install it in the biopacific env, e.g.\n"
+        "  pip install pyyaml\n"
+    )
+    sys.exit(1)
+
+root = os.environ["ROOT_DIR"]
+with open(os.environ["CONFIG_FILE"], encoding="utf-8") as fh:
+    cfg = yaml.safe_load(fh) or {}
+
+def resolve_path(value: str) -> str:
+    if not value:
+        return ""
+    return value if os.path.isabs(value) else os.path.normpath(os.path.join(root, value))
+
+def emit(name: str, value) -> None:
+    print(f"{name}={shlex.quote(str(value))}")
+
+emit("CFG_ENV_NAME",     cfg.get("env_name", "biopacific"))
+emit("CFG_SERVICE_HOST", cfg.get("service_host", "0.0.0.0"))
+
+q = cfg.get("qdrant") or {}
+emit("CFG_QDRANT_BINARY",       resolve_path(q.get("binary", "")))
+emit("CFG_QDRANT_STORAGE_PATH", resolve_path(q.get("storage_path", "")))
+emit("CFG_QDRANT_PORT",         q.get("port", 6333))
+
+pipeline = cfg.get("pipeline")
+if not isinstance(pipeline, dict):
+    sys.stderr.write("config.yaml: [pipeline] must be a mapping\n")
+    sys.exit(1)
+
+a = pipeline.get("s5_agent")
+if not isinstance(a, dict):
+    sys.stderr.write("config.yaml: [pipeline.s5_agent] must be a mapping\n")
+    sys.exit(1)
+if "service_port" not in a:
+    sys.stderr.write("config.yaml: [pipeline.s5_agent].service_port is required\n")
+    sys.exit(1)
+emit("CFG_AGENT_PORT", a["service_port"])
+
+for yaml_key, prefix in (("embedding", "EMBEDDING"),
+                         ("llm",       "LLM")):
+    s = cfg.get(yaml_key)
+    if not isinstance(s, dict):
+        sys.stderr.write(
+            "config.yaml: [%s] must be a mapping (section missing or wrong type)\n"
+            % yaml_key
+        )
+        sys.exit(1)
+    if "max_model_len" not in s:
+        sys.stderr.write(
+            "config.yaml: [%s].max_model_len is required "
+            "(per-service vLLM --max-model-len; no default)\n" % yaml_key
+        )
+        sys.exit(1)
+    emit(f"CFG_{prefix}_SERVED_NAME", s.get("served_name", yaml_key))
+    emit(f"CFG_{prefix}_MODEL_DIR",   resolve_path(s.get("model_dir", "")))
+    emit(f"CFG_{prefix}_PORT",        s.get("port", 0))
+    emit(f"CFG_{prefix}_GPU",         s.get("gpu", "0"))
+    emit(f"CFG_{prefix}_GPU_MEMORY_UTILIZATION",
+         s.get("gpu_memory_utilization", 0.8))
+    emit(f"CFG_{prefix}_MAX_MODEL_LEN", s["max_model_len"])
+PY
+  )"
+  eval "${dump}"
+}
+
+# ---------------------------------------------------------------------------
+# Per-service metadata lookup. Given a service name, populate globals:
+#   SVC_LABEL, SVC_KIND (vllm|qdrant|python), SVC_PORT, SVC_GPU, SVC_MEM,
+#   SVC_MODEL_DIR, SVC_SCRIPT_PATH, SVC_SERVED_NAME, SVC_LOG_FILE,
+#   SVC_PID_FILE, SVC_PGREP_PATTERN,
+#   SVC_DEFAULT_CHAT_TEMPLATE_KWARGS.
+# ---------------------------------------------------------------------------
+
+select_service() {
+  local svc="$1"
+  SVC_LABEL="${svc}"
+  SVC_LOG_FILE="${LOG_DIR}/${svc}.log"
+  SVC_PID_FILE="${LOG_DIR}/${svc}.pid"
+  case "${svc}" in
+    embedding)
+      SVC_KIND="vllm"
+      SVC_PORT="${CFG_EMBEDDING_PORT}"
+      SVC_GPU="${CFG_EMBEDDING_GPU}"
+      SVC_MEM="${CFG_EMBEDDING_GPU_MEMORY_UTILIZATION}"
+      SVC_MODEL_DIR="${CFG_EMBEDDING_MODEL_DIR}"
+      SVC_SERVED_NAME="${CFG_EMBEDDING_SERVED_NAME}"
+      SVC_MAX_MODEL_LEN="${CFG_EMBEDDING_MAX_MODEL_LEN}"
+      SVC_VLLM_RUNNER="pooling"
+      SVC_DEFAULT_CHAT_TEMPLATE_KWARGS=""
+      SVC_PGREP_PATTERN="vllm serve ${SVC_MODEL_DIR}"
+      ;;
+    llm)
+      SVC_KIND="vllm"
+      SVC_PORT="${CFG_LLM_PORT}"
+      SVC_GPU="${CFG_LLM_GPU}"
+      SVC_MEM="${CFG_LLM_GPU_MEMORY_UTILIZATION}"
+      SVC_MODEL_DIR="${CFG_LLM_MODEL_DIR}"
+      SVC_SERVED_NAME="${CFG_LLM_SERVED_NAME}"
+      SVC_MAX_MODEL_LEN="${CFG_LLM_MAX_MODEL_LEN}"
+      SVC_VLLM_RUNNER=""
+      SVC_DEFAULT_CHAT_TEMPLATE_KWARGS='{"enable_thinking": false}'
+      SVC_PGREP_PATTERN="vllm serve ${SVC_MODEL_DIR}"
+      ;;
+    qdrant)
+      SVC_KIND="qdrant"
+      SVC_PORT="${CFG_QDRANT_PORT}"
+      SVC_GPU="-"
+      SVC_MEM="-"
+      SVC_MODEL_DIR="${CFG_QDRANT_STORAGE_PATH}"
+      SVC_SERVED_NAME="qdrant"
+      SVC_VLLM_RUNNER=""
+      SVC_DEFAULT_CHAT_TEMPLATE_KWARGS=""
+      SVC_PGREP_PATTERN="${CFG_QDRANT_BINARY}"
+      ;;
+    agent)
+      SVC_KIND="python"
+      SVC_PORT="${CFG_AGENT_PORT}"
+      SVC_GPU="-"
+      SVC_MEM="-"
+      SVC_MODEL_DIR="-"
+      SVC_SCRIPT_PATH="${ROOT_DIR}/pipeline/s5-agent/paper_agent.py"
+      SVC_SERVED_NAME="paper-agent"
+      SVC_VLLM_RUNNER=""
+      SVC_DEFAULT_CHAT_TEMPLATE_KWARGS=""
+      SVC_PGREP_PATTERN="${SVC_SCRIPT_PATH}"
+      ;;
+    *)
+      die "Unknown service: ${svc}. Valid: ${SERVICES[*]}"
+      ;;
+  esac
+}
+
+# ---------------------------------------------------------------------------
+# Runtime utilities
+# ---------------------------------------------------------------------------
+
+port_in_use() {
+  "${PYTHON_BIN}" - "$1" <<'PY'
+import socket, sys
+port = int(sys.argv[1])
+with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    try:
+        s.bind(("0.0.0.0", port))
+    except OSError:
+        sys.exit(0)
+sys.exit(1)
+PY
+}
+
+validate_shared_gpu_budget() {
+  "${PYTHON_BIN}" - \
+    "${CFG_EMBEDDING_GPU}" "${CFG_LLM_GPU}" \
+    "${CFG_EMBEDDING_GPU_MEMORY_UTILIZATION}" \
+    "${CFG_LLM_GPU_MEMORY_UTILIZATION}" <<'PY'
+import sys
+labels = ["embedding", "llm"]
+gpus   = sys.argv[1:3]
+mems   = [float(x) for x in sys.argv[3:5]]
+
+per_gpu, per_gpu_who = {}, {}
+for label, gpu, mem in zip(labels, gpus, mems):
+    for single in gpu.split(","):
+        single = single.strip()
+        if not single:
+            continue
+        per_gpu[single] = per_gpu.get(single, 0.0) + mem
+        per_gpu_who.setdefault(single, []).append(label)
+
+bad = [(g, t, per_gpu_who[g]) for g, t in per_gpu.items() if t > 1.0]
+if bad:
+    for gpu, total, who in bad:
+        print(
+            f"GPU {gpu} is shared by {', '.join(who)} with a combined "
+            f"memory budget of {total:.2f} (> 1.0).",
+            file=sys.stderr,
+        )
+    print(
+        "Move one of the services to a different GPU, or lower the "
+        "gpu_memory_utilization values in config.yaml.",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+PY
+}
+
+gpu_count() {
+  local list="$1"
+  local IFS=','
+  local -a gpus=($list)
+  echo "${#gpus[@]}"
+}
+
+get_running_pid() {
+  local pid_file="$1"
+  local expected="$2"
+
+  if [[ -f "${pid_file}" ]]; then
+    local pid
+    pid="$(<"${pid_file}")"
+    if [[ -n "${pid}" ]] && kill -0 "${pid}" >/dev/null 2>&1; then
+      local cmdline
+      cmdline="$(ps -p "${pid}" -o args= 2>/dev/null || true)"
+      if [[ "${cmdline}" == *"${expected}"* ]]; then
+        echo "${pid}"
+        return 0
+      fi
+    fi
+  fi
+
+  if command -v pgrep >/dev/null 2>&1; then
+    local pid
+    pid="$(pgrep -f "${expected}" | head -n 1 || true)"
+    if [[ -n "${pid}" ]]; then
+      echo "${pid}" > "${pid_file}"
+      echo "${pid}"
+      return 0
+    fi
+  fi
+  return 1
+}
+
+wait_for_stop() {
+  local pid="$1"
+  for _ in $(seq 1 20); do
+    kill -0 "${pid}" >/dev/null 2>&1 || return 0
+    sleep 1
+  done
+  return 1
+}
+
+validate_vllm_targets() {
+  local -a targets=("$@")
+  local target
+  for target in "${targets[@]}"; do
+    if [[ "${target}" == "embedding" || "${target}" == "llm" ]]; then
+      validate_shared_gpu_budget
+      return 0
+    fi
+  done
+}
+
+wait_for_http_ready() {
+  local label="$1"
+  local method="$2"
+  local url="$3"
+  require_executable "$(command -v curl || true)" "curl"
+
+  local attempt
+  for attempt in $(seq 1 60); do
+    if [[ "${method}" == "POST" ]]; then
+      if curl --silent --show-error --fail \
+          -X POST \
+          -H "Content-Type: application/json" \
+          -d '{}' \
+          "${url}" >/dev/null 2>&1; then
+        echo "${label} is ready: ${url}"
+        return 0
+      fi
+    else
+      if curl --silent --show-error --fail "${url}" >/dev/null 2>&1; then
+        echo "${label} is ready: ${url}"
+        return 0
+      fi
+    fi
+    sleep 2
+  done
+
+  die "Timed out waiting for ${label} to become ready: ${url}"
+}
+
+wait_for_service_ready() {
+  local svc="$1"
+  select_service "${svc}"
+  case "${svc}" in
+    embedding|llm)
+      wait_for_http_ready "${svc}" GET "http://127.0.0.1:${SVC_PORT}/v1/models"
+      ;;
+    qdrant)
+      wait_for_http_ready "${svc}" GET "http://127.0.0.1:${SVC_PORT}/"
+      ;;
+    agent)
+      wait_for_http_ready "${svc}" POST "http://127.0.0.1:${SVC_PORT}/v1/session/start"
+      ;;
+    *)
+      die "Unknown service for readiness check: ${svc}"
+      ;;
+  esac
+}
+
+select_pipeline_stage() {
+  local stage="$1"
+  PIPELINE_STAGE_LABEL="${stage}"
+  PIPELINE_STAGE_LOG_FILE="${LOG_DIR}/${stage}.log"
+
+  case "${stage}" in
+    s1_index)
+      PIPELINE_STAGE_SCRIPT="${ROOT_DIR}/pipeline/s1-index/paper-index.sh"
+      ;;
+    s2_filter)
+      PIPELINE_STAGE_SCRIPT="${ROOT_DIR}/pipeline/s2-filter/paper-filter.sh"
+      ;;
+    s3_fetch)
+      PIPELINE_STAGE_SCRIPT="${ROOT_DIR}/pipeline/s3-fetch/paper-fetch.sh"
+      ;;
+    s4_embedding)
+      PIPELINE_STAGE_SCRIPT="${ROOT_DIR}/pipeline/s4-embedding/paper_embedding.sh"
+      ;;
+    *)
+      die "Unknown pipeline stage: ${stage}. Valid: ${PIPELINE_STAGES[*]}"
+      ;;
+  esac
+}
+
+run_pipeline_stage() {
+  local stage="$1"
+  select_pipeline_stage "${stage}"
+  require_file "${PIPELINE_STAGE_SCRIPT}"
+
+  echo "============================================================"
+  echo "Running pipeline stage: ${PIPELINE_STAGE_LABEL}"
+  echo "  script: ${PIPELINE_STAGE_SCRIPT}"
+  echo "  log:    ${PIPELINE_STAGE_LOG_FILE}"
+  echo "============================================================"
+
+  (
+    cd "${ROOT_DIR}"
+    env BIOPACIFIC_CONFIG="${CONFIG_FILE}" \
+      bash "${PIPELINE_STAGE_SCRIPT}"
+  ) 2>&1 | tee "${PIPELINE_STAGE_LOG_FILE}"
+}
+
+run_pipeline_sequence() {
+  local -a stages=("$@")
+  local stage
+  for stage in "${stages[@]}"; do
+    run_pipeline_stage "${stage}"
+  done
+}
+
+stop_services_in_order() {
+  local -a ordered=("$@")
+  local svc
+  for svc in "${ordered[@]}"; do
+    stop_one "${svc}"
+  done
+}
+
+run_full_start() {
+  local svc
+
+  validate_vllm_targets "${PREREQ_SERVICES[@]}"
+
+  echo "Starting prerequisite services: ${PREREQ_SERVICES[*]}"
+  for svc in "${PREREQ_SERVICES[@]}"; do
+    start_one "${svc}"
+  done
+
+  echo "Waiting for prerequisite services to become ready ..."
+  for svc in "${PREREQ_SERVICES[@]}"; do
+    wait_for_service_ready "${svc}"
+  done
+
+  echo "Running full pipeline: ${PIPELINE_STAGES[*]}"
+  run_pipeline_sequence "${PIPELINE_STAGES[@]}"
+
+  echo "Starting final service: agent"
+  start_one agent
+  wait_for_service_ready agent
+}
+
+# ---------------------------------------------------------------------------
+# Start / stop / status for a single service
+# ---------------------------------------------------------------------------
+
+start_one() {
+  local svc="$1"
+  select_service "${svc}"
+
+  local existing_pid
+  if existing_pid="$(get_running_pid "${SVC_PID_FILE}" "${SVC_PGREP_PATTERN}")"; then
+    echo "${SVC_LABEL} is already running with PID ${existing_pid} (log: ${SVC_LOG_FILE})"
+    return 0
+  fi
+
+  if port_in_use "${SVC_PORT}"; then
+    die "Port ${SVC_PORT} is already in use (needed by ${SVC_LABEL})."
+  fi
+
+  case "${SVC_KIND}" in
+    vllm)
+      require_executable "${VLLM_BIN}" "vllm"
+      require_dir "${SVC_MODEL_DIR}"
+      local tp_size
+      tp_size="$(gpu_count "${SVC_GPU}")"
+      local -a cmd=(
+        env "CUDA_VISIBLE_DEVICES=${SVC_GPU}"
+        "${VLLM_BIN}" serve "${SVC_MODEL_DIR}"
+        --host "${CFG_SERVICE_HOST}"
+        --port "${SVC_PORT}"
+        --served-model-name "${SVC_SERVED_NAME}"
+        --max-model-len "${SVC_MAX_MODEL_LEN}"
+        --gpu-memory-utilization "${SVC_MEM}"
+        --tensor-parallel-size "${tp_size}"
+        --trust-remote-code
+      )
+      [[ -n "${SVC_VLLM_RUNNER}" ]] && cmd+=(--runner "${SVC_VLLM_RUNNER}")
+      [[ -n "${SVC_DEFAULT_CHAT_TEMPLATE_KWARGS}" ]] && \
+        cmd+=(--default-chat-template-kwargs "${SVC_DEFAULT_CHAT_TEMPLATE_KWARGS}")
+
+      nohup "${cmd[@]}" > "${SVC_LOG_FILE}" 2>&1 &
+      local pid=$!
+      echo "${pid}" > "${SVC_PID_FILE}"
+      echo "${SVC_LABEL} started on port ${SVC_PORT}, GPU(s) ${SVC_GPU} (tp=${tp_size}), PID ${pid}"
+      echo "  log: ${SVC_LOG_FILE}"
+      ;;
+    qdrant)
+      require_executable "${CFG_QDRANT_BINARY}" "qdrant"
+      mkdir -p "${CFG_QDRANT_STORAGE_PATH}"
+      local -a cmd=(
+        env
+        "QDRANT__SERVICE__HOST=${CFG_SERVICE_HOST}"
+        "QDRANT__SERVICE__HTTP_PORT=${CFG_QDRANT_PORT}"
+        "QDRANT__STORAGE__STORAGE_PATH=${CFG_QDRANT_STORAGE_PATH}"
+        "QDRANT__TELEMETRY_DISABLED=true"
+        "${CFG_QDRANT_BINARY}"
+      )
+      ( cd "$(dirname "${CFG_QDRANT_BINARY}")" && \
+          nohup "${cmd[@]}" > "${SVC_LOG_FILE}" 2>&1 & echo $! > "${SVC_PID_FILE}" )
+      local pid
+      pid="$(<"${SVC_PID_FILE}")"
+      echo "${SVC_LABEL} started on port ${SVC_PORT}, storage ${CFG_QDRANT_STORAGE_PATH}, PID ${pid}"
+      echo "  log: ${SVC_LOG_FILE}"
+      ;;
+    python)
+      require_file "${SVC_SCRIPT_PATH}"
+      local -a cmd=(
+        env
+        "BIOPACIFIC_CONFIG=${CONFIG_FILE}"
+        "BIOPACIFIC_AGENT_HOST=${CFG_SERVICE_HOST}"
+        "${PYTHON_BIN}" "${SVC_SCRIPT_PATH}"
+      )
+      ( cd "${ROOT_DIR}" && \
+          nohup "${cmd[@]}" > "${SVC_LOG_FILE}" 2>&1 & echo $! > "${SVC_PID_FILE}" )
+      local pid
+      pid="$(<"${SVC_PID_FILE}")"
+      echo "${SVC_LABEL} started on port ${SVC_PORT}, script ${SVC_SCRIPT_PATH}, PID ${pid}"
+      echo "  log: ${SVC_LOG_FILE}"
+      ;;
+  esac
+}
+
+stop_one() {
+  local svc="$1"
+  select_service "${svc}"
+  local pid
+  if ! pid="$(get_running_pid "${SVC_PID_FILE}" "${SVC_PGREP_PATTERN}")"; then
+    rm -f "${SVC_PID_FILE}"
+    echo "${SVC_LABEL} is not running"
+    return 0
+  fi
+
+  kill "${pid}" >/dev/null 2>&1 || true
+  if wait_for_stop "${pid}"; then
+    rm -f "${SVC_PID_FILE}"
+    echo "${SVC_LABEL} stopped (PID ${pid})"
+    return 0
+  fi
+  echo "${SVC_LABEL} did not exit after SIGTERM; sending SIGKILL"
+  kill -9 "${pid}" >/dev/null 2>&1 || true
+  rm -f "${SVC_PID_FILE}"
+  echo "${SVC_LABEL} stopped (SIGKILL)"
+}
+
+status_one() {
+  local svc="$1"
+  select_service "${svc}"
+  local pid
+  if pid="$(get_running_pid "${SVC_PID_FILE}" "${SVC_PGREP_PATTERN}")"; then
+    printf "%-10s running   pid=%-7s port=%-5s gpu=%s\n" \
+      "${SVC_LABEL}" "${pid}" "${SVC_PORT}" "${SVC_GPU}"
+  else
+    printf "%-10s stopped             port=%-5s gpu=%s\n" \
+      "${SVC_LABEL}" "${SVC_PORT}" "${SVC_GPU}"
+  fi
+  echo "           log: ${SVC_LOG_FILE}"
+}
+
+# ---------------------------------------------------------------------------
+# Dispatch
+# ---------------------------------------------------------------------------
+
+usage() {
+  cat <<EOF
+Usage:
+  $(basename "$0") [start|stop|restart|status] [SERVICE ...]
+  $(basename "$0") pipeline [STAGE ...]
+
+Services: ${SERVICES[*]}
+Pipeline stages: ${PIPELINE_STAGES[*]}
+
+Config file: ${CONFIG_FILE}
+(Override via CONFIG_FILE env var.)
+
+Behavior:
+  - start / restart with no SERVICE arguments performs the full orchestrated flow:
+      start ${PREREQ_SERVICES[*]} -> run ${PIPELINE_STAGES[*]} -> start agent
+  - start / stop / restart / status with SERVICE arguments only manages
+    background services.
+  - pipeline runs one-shot foreground pipeline stages only.
+
+Examples:
+  $(basename "$0")                         # full bring-up
+  $(basename "$0") start                   # same as above
+  $(basename "$0") start llm qdrant        # start only these services
+  $(basename "$0") stop                    # stop all services
+  $(basename "$0") stop agent              # stop only the agent
+  $(basename "$0") restart                 # full stop + full bring-up
+  $(basename "$0") restart embedding       # restart one service
+  $(basename "$0") status                  # status of all services
+  $(basename "$0") pipeline                # run s1 -> s2 -> s3 -> s4
+  $(basename "$0") pipeline s3_fetch       # run only one pipeline stage
+EOF
+}
+
+resolve_service_list() {
+  local -a requested=("$@")
+  if [[ ${#requested[@]} -eq 0 || "${requested[0]}" == "all" ]]; then
+    printf '%s\n' "${SERVICES[@]}"
+    return
+  fi
+  for svc in "${requested[@]}"; do
+    local ok=0
+    for valid in "${SERVICES[@]}"; do
+      if [[ "${svc}" == "${valid}" ]]; then
+        ok=1; break
+      fi
+    done
+    [[ ${ok} -eq 1 ]] || die "Unknown service: ${svc}. Valid: ${SERVICES[*]}"
+    printf '%s\n' "${svc}"
+  done
+}
+
+resolve_pipeline_list() {
+  local -a requested=("$@")
+  if [[ ${#requested[@]} -eq 0 || "${requested[0]}" == "all" ]]; then
+    printf '%s\n' "${PIPELINE_STAGES[@]}"
+    return
+  fi
+  local stage valid ok
+  for stage in "${requested[@]}"; do
+    ok=0
+    for valid in "${PIPELINE_STAGES[@]}"; do
+      if [[ "${stage}" == "${valid}" ]]; then
+        ok=1
+        break
+      fi
+    done
+    [[ ${ok} -eq 1 ]] || die "Unknown pipeline stage: ${stage}. Valid: ${PIPELINE_STAGES[*]}"
+    printf '%s\n' "${stage}"
+  done
+}
+
+is_full_orchestration_request() {
+  [[ $# -eq 0 ]] && return 0
+  [[ $# -eq 1 && "$1" == "all" ]] && return 0
+  return 1
+}
+
+main() {
+  local action="start"
+  if [[ $# -gt 0 ]]; then
+    case "$1" in
+      start|stop|restart|status|pipeline) action="$1"; shift ;;
+      -h|--help)                 usage; exit 0 ;;
+      *) # first token is already a service name -> implicit "start"
+         ;;
+    esac
+  fi
+
+  # Need python to load config.
+  use_preferred_runtime "biopacific"   # env_name gets overridden once config loads
+  load_config
+  use_preferred_runtime "${CFG_ENV_NAME}"
+
+  case "${action}" in
+    start)
+      if is_full_orchestration_request "$@"; then
+        run_full_start
+      else
+        local -a targets=()
+        local t
+        mapfile -t targets < <(resolve_service_list "$@")
+        validate_vllm_targets "${targets[@]}"
+        for t in "${targets[@]}"; do start_one "${t}"; done
+      fi
+      ;;
+    stop)
+      local -a stop_targets=()
+      local t
+      if is_full_orchestration_request "$@"; then
+        stop_services_in_order "${STOP_ORDER[@]}"
+      else
+        mapfile -t stop_targets < <(resolve_service_list "$@")
+        for t in "${stop_targets[@]}"; do stop_one "${t}"; done
+      fi
+      ;;
+    restart)
+      if is_full_orchestration_request "$@"; then
+        stop_services_in_order "${STOP_ORDER[@]}"
+        run_full_start
+      else
+        local -a restart_targets=()
+        local t
+        mapfile -t restart_targets < <(resolve_service_list "$@")
+        for t in "${restart_targets[@]}"; do stop_one "${t}"; done
+        validate_vllm_targets "${restart_targets[@]}"
+        for t in "${restart_targets[@]}"; do start_one "${t}"; done
+      fi
+      ;;
+    status)
+      local -a status_targets=()
+      local t
+      mapfile -t status_targets < <(resolve_service_list "$@")
+      for t in "${status_targets[@]}"; do status_one "${t}"; done
+      ;;
+    pipeline)
+      local -a stages=()
+      local stage
+      mapfile -t stages < <(resolve_pipeline_list "$@")
+      run_pipeline_sequence "${stages[@]}"
+      ;;
+    *)
+      usage; exit 1 ;;
+  esac
+}
+
+main "$@"