MCP App Store
by KeenEthics
Tamarind Bio icon

Tamarind Bio MCP Server for Claude and ChatGPT

By Tamarind Bio

Overview

Connect ChatGPT to your Tamarind Bio workspace for protein and molecular science. Validate, estimate, submit, and monitor jobs across 300+ tools — structure prediction, docking, protein and antibody design, molecular dynamics, and property prediction. Chain tools into pipelines, batch many inputs at once, and pull back structures, results, and logs — all from chat.

How to connect

  1. Claude: Open the Tamarind Bio listing in the Claude connectors directory and choose Connect. Claude listing Tamarind Bio exposes 18 tools here.
  2. ChatGPT: Open the Tamarind Bio listing in the ChatGPT app directory and choose Connect. ChatGPT listing Tamarind Bio exposes 66 tools here.

Tools

cancelAssay

ChatGPT
Cancel one of your assay orders. It cannot be undone, so confirm with the user first. An order Tamarind has not approved yet is cancelled straight away. One already sent to Ginkgo shows as cancelling until Ginkgo confirms. Adaptyv orders cannot be cancelled here; tell the user to contact Tamarind support. The order's cancellable field (from listAssays) says whether this will work now. Cancelling an order that is already cancelled is fine: you get it back. Errors (409 and 502 carry a code): - 400 not_cancellable: not in a state that can be cancelled; status shows where it is. - 409 approval_in_progress: Tamarind is approving it right now. Try again in a minute. - 409 approval_under_review: tell the user to contact support. Do not retry. - 409 order_changed: look the order up again with listAssays. - 502 cancel_unconfirmed: check the order with listAssays before trying again. Responses: - 200 (Success): The order, now cancelled or cancelling - Content-Type: application/json - Response Properties: - Example: ``json { "assay": "unknown_type" } ` - **400**: assayId is missing, or the order can't be cancelled in its current state (not_cancellable) - **401**: Missing or invalid API key - **404**: You don't have an order with this assayId - **409**: Can't be cancelled right now (approval_in_progress, approval_under_review, order_changed) - **502**: The cancellation couldn't be confirmed (cancel_unconfirmed`)

cancelBatch

ChatGPT
Soft-stop every member of a batch or pipeline in one call. Flips JobStatus to "Stopped" on all batch children, all pipeline stages, and the pipeline parent row (if one exists). Doesn't delete rows or outputs. Use this when the user wants to stop a batch or pipeline as a unit. Don't call cancelJob N times — this fans out server-side via the Batch-index GSI in one round-trip. Pipeline support is for LEGACY pipelines only: their stages carry Batch=<pipeline_name>, so a pipeline name resolves through the same index a batch name does, and the parent row (Type='pipelines') is looked up separately via JobName-index and cancelled too. This does NOT stop a run created by submitPipeline. Those are Type='pipeline-run', a deliberately different job type that neither index reaches — use stopPipelineRun(runId) for them. Only cancels jobs in "In Queue", "Running", or "Pending" status — already-terminal jobs are skipped. Responses: - 200 (Success): Batch cancellation summary - Content-Type: application/json - Response Properties: - cancelledCount: Number of rows successfully flipped to Stopped. - totalChildren: Total batch/pipeline children found (any status). - cancellableChildren: Children in In Queue / Running / Pending — the subset eligible for cancel. - parentCancelled: True if a pipeline parent row was found and cancelled too. - Example: ``json { "success": true, "message": "Cancelled 12 jobs in batch \"my-batch\"", "batchName": "string" } `` - 400: batchName missing or invalid - 401: Unauthorized - 404: No batch or pipeline with that name found for this user

cancelJob

ChatGPT
Soft-stop a job — flips JobStatus to "Stopped" (same value the website cancel button writes) without deleting the row or outputs. Only works on jobs in "In Queue", "Running", or "Pending" status; jobs already in a terminal state are rejected with 400. Accepts either jobName (preferred — looked up via JobName-index GSI server-side, no need for callers to know the Id) or jobId (the DDB Id, if already known). At least one is required. Different from deleteJob, which permanently removes the row + outputs. cancelJob preserves both. Responses: - 200 (Success): Job cancelled - Content-Type: application/json - Response Properties: - Example: ``json { "success": true, "message": "Job cancelled successfully", "jobId": "string" } `` - 400: Job not in a cancellable state (already Completed / Failed / Cancelled) - 401: Unauthorized - 403: Access denied (job belongs to another user) - 404: Job not found

createBenchmarkDataset

ChatGPT
Create a benchmark dataset from a Molecules group of reference structures. Requires benchmark access. Import structures with importMoleculeFile and wait for getMoleculeImport first, or use an existing group from listMoleculeGroups. Returns an accepted dataset, not completed setup. Poll getBenchmarkDataset with a deadline until status is complete, then check setUp, problems and finalizeError before estimating a run.

createBenchmarkDatasetFromStructures

ChatGPT
Create a benchmark dataset from PDB IDs and/or structure files; the server makes the Molecules group. Requires benchmark access. Send pdbIds, files or both, at most 1000 in all. Returns an accepted dataset, not completed setup. Poll getBenchmarkDataset with a deadline until status is complete, then check setUp, problems, warnings, failedNames and uploadError before estimating a run. A structure that could not be imported is listed in failedNames with its reason.

createMolecules

ChatGPT
Create a NAMED, reusable molecule group and return its groupId — the id you bind as {"group": "<groupId>"} in submitPipeline/validatePipeline. You do not need this to run a pipeline once: a binding takes raw values inline ({"sequences": [...]}, {"smiles": [...]}) and the server mints a throwaway group. Use this when you want a cohort you can name, find again with listMoleculeGroups(), and bind across MANY runs — or when you want per-molecule metadata that searchMolecules() can later filter and rank on. CSVs: read the file yourself and pass one object per row — the name column as "name", the sequence/SMILES column as the chain, and every other column inside "metadata". Mapping the columns deliberately beats a server-side guess, and metadata is exactly what searchMolecules() filters on afterwards. TEXT CHAINS ONLY — sequences and SMILES. Use importMoleculeFile for uploaded PDB structures, then getMoleculeImport until ingested before binding them. LIGANDS: use the {"smiles": "..."} shorthand and the kind is declared for you. If you instead spell a ligand out under "entity", you MUST say so via chainMapping, e.g. entity {"A": "MKT...", "B": "CCO"} with chainMapping {"B": {"type": "small_molecule"}} — the server cannot infer it, because a SMILES made only of sequence letters (CCO is ethanol AND a tripeptide) reads as a protein and then fails validation. A per-molecule "type": "small_molecule" does NOT do this; only chainMapping does. Nucleic acids are the other way round: give the MOLECULE "type": "nucleic_acid" and its chains follow. This waits for the upload to finish ingesting before returning, so a status: "ingested" group is ready to bind. If the wait runs out you still get the groupId, but with status: "pending" — do NOT bind that one yet. A partly ingested group passes validation (only a completely EMPTY one is rejected) and would run over however many molecules had landed by then. Chain labels must be 1-4 UPPERCASE letters or digits ("A", "H", "L", "AB1"). Descriptive labels like {"heavy": ..., "light": ...} are rejected — put the description in "name" and use {"H": ..., "L": ...} for the chains. METADATA IS SHARED BY IDENTICAL MOLECULES, and identical means identical CHAINS — the same sequence uploaded into two groups is ONE molecule with ONE set of annotations, org-wide. Importing that sequence again with different metadata OVERWRITES the earlier values (per key), and re-importing it with different tags silently keeps the ORIGINAL tags. So a key like {"round": 2} does not mean "round 2 in this group" — if you need per-cohort annotations, use a key that names the cohort, or keep the distinction in the group name and tags. Args: name: Name for the group, 1-200 characters. Required. molecules: 1-1000 molecules. A string is one chain; an object takes {"entity": {"A": "...", "B": "..."}} (or {"sequence"}/{"smiles"} for a single chain) plus optional "name", "type", "metadata", "tags". Any OTHER key is rejected — annotations go inside "metadata", not beside it. Example: [{"name": "d1", "sequence": "MKT...", "metadata": {"round": 2}}] type: Molecule kind for the GROUP — one of protein, antibody, peptide, enzyme, small_molecule, nucleic_acid, small_molecule_binding_protein. Per-molecule types are inferred; omit unless the group is uniform and you want it labelled. tags: Tags for the group. chainMapping: Per-CHAIN-LABEL declarations, {label: {"type": "protein" | "small_molecule", "tags": ["heavy"|"light"|"lead"]}}. Needed only when you spell a ligand out under "entity" — the {"smiles": ...} shorthand fills this in for you. Keyed by label and applied to the WHOLE upload, so a label means the same thing in every molecule of one call. waitSeconds: How long to wait for ingestion, 0-300 (default 60). Pass 0 to return as soon as the upload is accepted. Returns: JSON: { groupId, name, moleculeCount, moleculeIds, status, importId }. status is "ingested" (ready to bind), "pending" (still ingesting — the group is real but NOT yet safe to bind; poll listMoleculeGroups until that group's status is "ready") or "failed". …

createProject

ChatGPT
Create a project, so a job can be tagged with it. CALL listProjects FIRST. An organization that requires project tags is usually curating that list deliberately, and a near-duplicate project is worse than reusing one — it fragments the job history the requirement exists to keep together. If nothing on the list fits, ask the user before creating rather than inventing a name for them. Args: name: Project name, unique within the scope. Required. description: Optional free text. scope: "org" (default) creates it for your whole organization, which is the ONLY scope that satisfies a required-project policy. "personal" creates a private one, which does NOT satisfy it and is only meaningful if you belong to an organization. Returns: JSON { created: {id, name, scope}, hint }. Pass id (or name) as projectTag on your next submitJob / submitBatch.

deleteBenchmark

ChatGPT
Archive your benchmark. It then reads as 404. Requires benchmark access. The MolDB group and its scores are kept. Stop running runs first if you want them to end. Returns {} on success.

deleteBenchmarkRun

ChatGPT
Archive your benchmark run. Its API details and results then return 404. Requires benchmark access. Jobs and original files are kept. Stop active runs first; run_active or launch_in_progress refuses deletion. Returns {} on successful archival.

deleteFile

ChatGPT
Delete a workspace file (or a whole folder) from your Tamarind account. Pass filePath to delete one file, or folder to delete every file under a folder. After a successful delete the cached file listing is invalidated, so the file stops appearing in getFiles/getFileStats immediately. Args: filePath: Name/path of the file to delete (e.g. "path/to/myFile.txt"). folder: Folder path — deletes all files under it. Returns: JSON confirmation, e.g. {"message": "File deleted successfully"}.

deleteJob

ChatGPT
Permanently delete a job by name (if it's a batch, all of its subjobs are deleted too). Unlike cancelJob (which only stops a running job without removing it), this permanently removes the job row and its outputs. Returns a plain-text confirmation; raises a clean error if the job doesn't exist or isn't yours. Args: jobName: Name of the job (or batch) to delete. Returns: Plain-text confirmation, e.g. "myJob deleted".

deployCustomTool

ChatGPT
Deploy your organization's own code as a Tamarind tool: create it if needed, upload the source, build an image, run a build as a test, and publish it. Calling this again with new source IS the update path — there is no separate update call. Identical source returns unchanged without rebuilding, and a code-only change returns reuse_image and skips the image build. Exactly one mode per call: - BUILD — pass files (and binaryFiles). Creates the tool if it does not exist, uploads, and starts a build. - TEST — pass testVersion (and testSettings) to run a Complete build as a job in the tool's Test history on the website, without publishing it. It runs the tool, so it uses compute. An identical test runs once; calling again reports that run. - PUBLISH — pass publishVersion alone to promote an already-built version. This is also how you roll back: publish an older completed version. - CANCEL — pass cancelVersion alone to stop an in-progress build. SOURCE FORMAT. files maps archive-relative path to text content; Dockerfile, run.sh, and config.json belong at its ROOT. Binary members go in binaryFiles as base64. At runtime the working directory is /app, scalar inputs arrive as environment variables named after config.json's inputs[], file inputs arrive as absolute paths under /app/inputs/ (which is writable, so a tool whose code wants its input at a fixed path can stage it there), results must be written to /app/out/, and THE CONTAINER HAS NO NETWORK — bake packages and model weights into the image in the Dockerfile, which does have network. Bake them OUTSIDE /app (use /opt/<tool>/): the uploaded source replaces /app at runtime, so anything the Dockerfile fetches there is missing when the job runs, even though it passed its build-time checksum. PUBLISHING IS ORGANIZATION-WIDE. It changes what every member gets when they submit this tool, so only pass publish=True (or publishVersion) once the user has authorized that exact promotion. Args: name: Organization-unique tool name. files: {"Dockerfile": "...", "run.sh": "...", "config.json": "..."} — text content. binaryFiles: Same shape for binary members, base64-encoded. displayName: Human-readable name. Used only when the tool is created. description: One-line description. Used only when the tool is created. publish: Publish the new version once it builds. Requires waitSeconds > 0, so it only lands when no image build was needed. Otherwise publish separately with publishVersion once the build is Complete. waitSeconds: Poll the build for up to this long (max 45 — MCP clients abort longer calls). 0 returns immediately. An image build takes minutes, so expect to poll with getCustomTool rather than wait here. validateOnly: Check and hash the archive without creating or uploading anything. publishVersion: PUBLISH mode — the version.id returned by build or getCustomTool to promote. cancelVersion: CANCEL mode — the version.id returned by build or getCustomTool to cancel. testVersion: TEST mode — the version.id returned by build or getCustomTool to run. testSettings: TEST mode — the run's inputs, named as in config.json inputs[]. projectTag: TEST mode — the organization project id to file the run under (listProjects). Orgs that require a project tag refuse a test without one. idempotencyKey: Optional stable key for retrying the same build after an ambiguous response. Reuse only for the same source and runtime request; a different request conflicts. In TEST mode, a new key runs an identical test again. expectNew: Refuse to update an existing tool. Pass True whenever you believe the name is free — a listing is a snapshot, and another member can claim the name between your check and this call. Returns: JSON. Build: {"action": "build"|"reuse_image"|"unchanged", "version", "sourceDigest", "published"}. action: "unchanged" means identical source already has a version and nothing was rebuilt. Poll with getCustomTool until the version is terminal. Test: {"action": "test", "version", "job": {"jobName", "id", "status"}}; follow the job with getJobs(jobNam…

estimateBenchmark

ChatGPT
Price a benchmark's pending cells without launching anything. Requires benchmark access. Returns {weightedHours, jobs, cells}; all zero when nothing is pending. To price a change before making it, call validateBenchmark with the update body.

estimateFeatureExtraction

ChatGPT
Validate and price an extraction without creating jobs. Requires extraction access. Returns totalJobs, totalWeightedHours and per-feature estimates, including prerequisite structure jobs. Fix all validation findings and obtain the user's compute authorization before extractFeatures.

estimatePipeline

ChatGPT
Price a pipeline run WITHOUT running it. This spends NOTHING — no run, no jobs, no saved template, no molecule group is created. Call it before submitPipeline to check what a run will cost. Takes exactly the arguments submitPipeline prices: the graph (pipeline or templateId+version), bindings, settings and name, and prices exactly what submitPipeline would run — the same version (explicit version, else published-then-latest) and the same molecules, raw-value bindings included. submitPipeline's runName, project and idempotencyKey only name and tag the run, so they are not taken here. totalWeightedHours is the number the platform's budget gate enforces when the run is submitted, so compare THAT against a budget. perNode breaks it down by pipeline node (molecules in/out, jobs, weightedHours each), and assumptions says what the figure takes for granted — chiefly that every molecule passes every filter, so a filtered pipeline usually costs less than quoted. estimateFailed: true means there is NO quote: the platform could not price the run, and the totals are not a cost (in particular, not a zero cost). Do not read a failed estimate as "free" or as within budget. If estimateUnavailable comes back, the estimator could not be reached and the run was NOT priced — retry once or twice. Any other error means the run was refused (an unknown template, a bad setting override, ...); call validatePipeline on the same graph and bindings for per-node diagnostics. Args: name: A name for the pipeline/run. Required. bindings: One entry per input node, keyed by the input node's id, exactly as for submitPipeline: {"group": "<groupId>"} for an existing molecule group, or raw values — {"sequences": [...]}, {"smiles": [...]}, {"pdbs": ["<uploadedPath>"]}, {"sdfs": [...]} — which are priced as the group submitPipeline would create from them (none is created here). A file input takes {"file": "<path>"}. "residuesByChain" and "chainMapping" go in the binding as for submitPipeline. pipeline: INLINE mode — a full pipeline IR. Mutually exclusive with templateId. templateId: REFERENCE mode — an existing template. version: REFERENCE mode only — a version handle like "v2". Omit for published-then-latest, the version submitPipeline would run. settings: Per-node overrides {nodeId: {settingKey: value}}; in REFERENCE mode limited to the template's editable settings. Returns: JSON: { totalWeightedHours, totalJobs, estimateFailed, perNode: [{node, tool, label, molecules, outputMolecules, jobs, weightedHours}], assumptions: [str] }.

estimateTime

ChatGPT
Estimate how LONG a job will run and how many WEIGHTED (compute) HOURS it will cost — BEFORE submitting anything. Use it to plan a run, compare tools, warn the user about a slow or expensive job, or budget a design loop. The number returned is the SAME estimate the submit path's budget gate uses, so it matches what submitting this job would quote. No job is created. Returns JSON: { jobType, numJobs, perJobRuntimeSeconds, perJobRuntimeHuman, tier, weightedHours?, note? } - perJobRuntimeSeconds / perJobRuntimeHuman: wall-clock estimate for ONE job. - numJobs: how many jobs these settings expand into (e.g. multiple sequences). - weightedHours: total compute-hour cost across the whole submission (the billing unit). Returned for PREMIUM users only; free users get note instead, mirroring the website (compute cost is shown to Premium users only). Args: type: Tool name — see getAvailableTools(). settings: Job settings object — see getJobSchema(jobType=type). Estimate one job at a time (a single settings object, not a list). jobName: Optional; does not create a job and does not affect the numbers. Leave as the default. atomCount: Optional atom count for MD tools (gromacs/openmm) whose runtime scales with system size; a typical default is used when omitted.

extractFeatures

ChatGPT
Start a caller-selected feature panel as one pipeline. This spends compute; estimate first. Supply and retain idempotencyKey before calling. Returns runId, status and that same key. Poll getFeatureExtraction, then getFeatureExtractionBundle. In-app agent starts with chat callbacks are not supported yet. An uncertain response is not a refusal: reuse the returned key and identical inputs/settings to recover it. A group uses the native pipeline group path; inline inputs are limited to 500. Normal budgets apply.

getAgentBuilder

ChatGPT
Read the user's agents and skills, and what they can be built from (what the web app's Customize shows). Args: what: One of: "catalog": what a definition's capabilities keys, subagents names, skills and effort must come from, and for staff its model. "agents": the user's saved agents, and those colleagues published to their org. Only agents are theirs to change. "agent": one agent, by id. tamarind is the Tamarind agent, which every chat with no saved agent runs as. "skills": the user's own skills and their org's. An agent names one in custom_skills by its id. "skill": one skill by id, with its SKILL.md and other files. id: The agent's (agt_...) or skill's (skl_...) id, for "agent" or "skill". version: An older version to read, for "agent" or "skill". tamarind keeps only its latest. Returns: JSON. For "agent": { agent, version: {version, definition, ...} }, and for tamarind also org_default, the org's settings beneath the user's. To change one, edit definition and pass version.version to saveAgent as expectedVersion. For "skill": { skill, version: {version, definition: {skill_md, ...}, ...}, files: {path: text} }. Pass version.version to saveSkill.

getAvailableModels

ChatGPT
List the models you can FINETUNE (train) — the finetuning tools available to you, e.g. "chemprop-finetune" or "plm-finetune". Not the same as listFinetunedModels, which lists models you have ALREADY trained (and can run). This lists what you can train NEW models with. Next steps: 1. getJobSchema(jobType="<name>") for the tool's training settings. 2. submitFinetuningRun(model="<name>", jobName=..., settings=...). 3. The trained model shows up in listFinetunedModels; once its status is "Available", run it with submitJob (type = its inferenceType, modelId = its id). The same tools are also listed by getAvailableTools. Args: search: Optional — keep tools whose name, displayName or description contains this text. Returns: JSON with tools (name, displayName, categories, outputTypes, tags, description — the same row shape as getAvailableTools) and totalTools.

getAvailableTools

ChatGPT
Get list of all available tools/job types in the Tamarind platform. Use this tool BEFORE submitting jobs to discover what tools are available. The catalog is large, so FILTER rather than listing everything: narrow by modality (the molecule type) and/or function (what the tool does), or by a free-text search. Call listModalities() and listTags() first to see the valid values (with descriptions) for those two filters. Args: modality: Filter by molecule type (e.g. "antibody", "protein", "peptide", "small-molecule", "nucleic-acid"). See listModalities(). function: Filter by what the tool does (e.g. "structure-prediction", "binder-design", "protein-ligand-docking"). See listTags(). category: Deprecated alias for modality (still honored). tag: Deprecated alias for function (still honored). search: Search in tool name or description custom: If true, return only custom tools; if false/None, return standard tools from database The catalog drifts as tools are added/removed, so don't guess values — every response includes the exact live availableCategories and availableTags (a.k.a. modalities and functions) computed from the current catalog, or call listModalities()/listTags() for the same vocabulary with descriptions. Returns: JSON with tools (name, displayName, categories, outputTypes[, tags, description]), plus availableCategories and availableTags — the live facet lists to filter against. outputTypes is what a tool declares it produces — molecular (pdb, sequence, sdf, smiles) and otherwise (csv, score, cif, ...). A few tools use compound values such as "pdb-list" or "sequence-list", so match by CONTAINMENT, not equality. Use it to plan a multi-step run: a molecular type here must cover what the next tool takes as input. It is OMITTED when the tool declares nothing, which means UNKNOWN — not "produces nothing", so confirm with getJobSchema rather than ruling the tool out. A type here is also not proof the tool GENERATED it: a scorer can echo its input sequence alongside the scores. getJobSchema's taskType is what distinguishes generating from scoring, along with the full result contract — the results CSV and its columns, i.e. the metric names to filter or rank on. Examples: - Find antibody tools: modality="antibody" - Find structure prediction tools: function="structure-prediction" - Narrow to antibody structure prediction: modality="antibody", function="structure-prediction" - Search for AlphaFold variants: search="alphafold" - Find custom tools: custom=true

getBenchmark

ChatGPT
Read a benchmark. For Tamarind's published data, use an id from listBenchmarks(scope="public"). Public ids return the existing hosted board's models, tasks, scoring definitions and sources. Public data keeps its original resultSchema and has readOnly=true; no org, group, revision or run is fabricated. For a native custom benchmark, this returns its definition, revision and status and requires benchmark access. status.state is idle, running (a run is in flight) or cap_reached (pending cells would pass maxWeightedHours; raise it with updateBenchmark). status.cells counts pending, running, done, failed, stopped and skipped cells; pendingEstimate prices the cells not yet launched. Send revision back on updateBenchmark. Archived or inaccessible benchmarks return 404.

getBenchmarkResults

ChatGPT
Read benchmark results and published model comparisons from Tamarind Benchmarks. For questions about Tamarind's benchmark scores or data, discover the public id with listBenchmarks(scope="public"), then call this tool. No prediction or evaluation is launched. Public ids read existing published data; native ids read the caller's custom benchmark results. Public results declare source=hosted and resultSchema. statistics keeps the published leaderboard, units and denominators; items keep interface or POISK binder/decoy pair scores. No new computation runs. Public task/subset/target filters apply only to hosted data. Start with limit=0 for the statistics. json returns {statistics, items, next}: statistics ranks each model on each metric (value, n, rank, coverage; a benchmark without models has values at the top level) and comes on every page; items are one per row with each model's cell status and values (design models nest their designs). Start with limit=0 for the leaderboard alone. csv returns {"csv": text}, one line per (row, model[, design]); per-model statistics are only in json. For native custom benchmarks, models are compared only on rows every one of them has a value for (n, comparedRows), so while one model's cells are still running a statistic can be null for every model: wait until getBenchmark says idle. A pass_rate metric's per-row/per-design value is 1 (pass) or 0 (fail).

getBenchmarkRun

ChatGPT
Read a benchmark run's status, counts and launch state. Requires benchmark access. Poll with a deadline until finished, partial, stopped or failed. Status can be unknown just after launch. launch.state is reserved, submitted or failed; browser-created runs may have no launch record. A read failure is not a reason to launch another run. Deleted or inaccessible runs return 404.

getBenchmarkRunResults

ChatGPT
Read benchmark results in bounded responses after a run ends. Requires benchmark access. Small snapshots return benchmark-results/v1 unchanged. Large snapshots return summaryOnly with section counts. Select section="files" to list keys for result files, then use section="files", key=<one key> to read its value. Other sections include nodeRuns, jobs, modelFiles, excluded and pendingArtifacts. Listings return keys/items, at most 20 per page. A small selected value returns kind="value" and value. A large value returns kind="chunk", JSON text fragments and nextOffset; concatenate text from consecutive chunks before parsing JSON. Continue the same selection using nextOffset and its contentHash as expectedHash. Omit expectedHash when changing section/key. If results_changed is returned, discard accumulated pages and restart that selection. Responses are capped at 16,000 JSON characters; this still fetches the backend snapshot on each call. run_not_finished means poll getBenchmarkRun first. {building: true} means retry shortly. Parse the benchmark.json text entries in files, then their results rows: score is DockQ; rows without scores carry errors. pendingArtifacts lists scoring jobs whose files are missing. Even an empty list does not establish completeness: unreadable nodes may be absent. Fetch again to refresh. Before attributing a score, check modelFiles provenance against the run's predictor jobs; a reused model file can come from another run on the same molecule.

getCustomTool

ChatGPT
Inspect your organization's custom tools, or poll one tool's build. Call with no name to list the custom tools your organization owns, including Drafts that are not yet published. Published custom tools are also visible as ordinary tools through getAvailableTools(custom=True), with their submit schema through getJobSchema. Call with a name to get that tool plus one version's build status and logs — this is the polling call after deployCustomTool. Add listVersions=True to get the tool's version history instead, newest first; that is where a rollback target comes from, because publishing an older Complete version IS the rollback. Stop when the version's terminal is true; statuses are Queued, Running, Complete, and Stopped, and a terminal build can carry a structured error. Build-log cursors stay live while a build runs: carry logs.nextCursor into the next poll and sleep between polls. A REPEATED non-null cursor means "no new logs yet", not "drain another page immediately". It goes null once the terminal log stream is exhausted. Args: name: The tool's name. Omit to list every custom tool in the organization. version: The version.id returned by build, or "latest" (default) for the newest. listVersions: With name, list that tool's versions newest-first instead of reading one. This is how you find a rollback target — an older version whose status is Complete. Paginate with cursor. logCursor: logs.nextCursor from the previous poll, to resume the log stream. cursor: Listing mode only — nextCursor from the previous page. Follow it until null. Returns: JSON. Without name: {"items": [...], "nextCursor": ...}. With name: {"tool", "version", "logs"}. With listVersions: {"tool", "versions": [...], "nextCursor"}.

getFeatureExtraction

ChatGPT
Read extraction and per-feature job status. Poll with a finite deadline; failed features retain their reasons.

getFeatureExtractionBundle

ChatGPT
Get a private download URL for features.csv, statuses, provenance and native embedding files. state=running/building means poll again after retryAfter. ready includes a URL valid for 15 minutes. Partial runs retain successful features; inspect features_status.csv. 413 requires a smaller export; a retryable 409 may be retried. Native tensors are downloaded as files, never expanded into this tool response.

getFeatureExtractionCatalog

ChatGPT
List compatible feature recipes and their configurable settings. Requires extraction access. Choose recipe keys from featureSets; settingsSchema gives permitted settings, required values and defaults. Catalog visibility preserves the caller's tool access and licensing. maxSequences limits inline inputs only; an existing molecule group is not subject to that inline count limit.

getFileStats

ChatGPT
Get summary statistics about available files (counts by type). Use this BEFORE getFiles() to understand what file types are available and decide what to filter for. Returns: JSON with file counts by type and total count

getFiles

ChatGPT
List files available in the Tamarind workspace with filtering. IMPORTANT: This returns a LIMITED subset of files to avoid context overflow. Use 'types' and 'search' parameters to filter before listing. Use 'offset' to paginate through results. Args: types: Comma-separated file types to filter (e.g., "pdb,cif"). HIGHLY RECOMMENDED to avoid getting too many results. search: Search term to filter filenames (e.g., "output", "job123") limit: Maximum number of files to return (default 100, max 500) offset: Number of files to skip for pagination (default 0) includeMetadata: Include file size and modification time Returns: JSON with files array, count, hasMore flag, and total count Examples: - List PDB files: types="pdb" - Search for specific job: search="job_12345" - Get next page: offset=100, limit=100

getFolders

ChatGPT
Retrieve a list of folders in the user's storage Query Parameters: - limit: Maximum number of folders to return - offset: Number of folders to skip - loadAll: Load all folders without pagination Responses: - 200 (Success): List of folders - Content-Type: application/json - Response Properties: - hasMore: Whether there are more folders available - total: Total number of folders - offset: Current offset in the results - limit: Maximum number of folders returned - Example: ``json { "folders": [ "string" ], "hasMore": true, "total": 1 } ` - **401**: Unauthorized - **500**: Internal server error - Content-Type: application/json - **Response Properties:** - **Example:** `json { "error": "Failed to fetch folders" } ``

getJobFile

ChatGPT
Download job output files — ONE call, ONE link, however many files. Give it the "jobName/fileName" paths you want. Those are exactly the s3Path values listJobFiles() returns, so pass them straight through: getJobFile(files=["my-job/results.csv"]) one file getJobFile(files=["job-a/x.csv", "job-b/y.csv"]) any number Use listJobFiles() first to see what exists — this tool does not search, it fetches exactly what you name. A whole batch is therefore two calls: found = listJobFiles("my-batch-", "-scores.csv")["files"] getJobFile(files=[f["s3Path"] for f in found]) Do NOT call this once per file. One call takes the whole set; a loop is what makes a batch download slow and floods the context. You get back a short-lived downloadUrl plus a files manifest of what it covers. Fetch everything with the single command in instructions: curl -fsS -o results.zip "<downloadUrl>" && unzip -o results.zip -d <DEST> One file streams raw; many files stream as a zip. As a convenience, a SINGLE text file under 256 KB comes back as content inline instead, so reading one log or CSV stays a single call. Pass maxSizeMB=0 to decline that and always get a downloadUrl — do that when you want the file ON DISK, since a 256 KB log inlined is ~65K tokens of context spent on bytes you meant to save. When you want only PART of what a glob matches — "batch 28 and onwards", "the ten largest" — filter the listJobFiles() result in code and pass the paths you kept. IF curl FAILS with "could not resolve host" / "network unreachable" / HTTP 000, your MCP client's sandbox is blocking outbound network. The MCP tools still work (they go through the client, not your shell) — only curl needs egress to the downloadUrl's host, which is named in instructions. Tell the USER to allow that host (Claude Desktop/Claude.ai: Settings -> Capabilities -> "Allow network egress"; other clients: their network allowlist), then re-run the curl. Args: files: List of "jobName/fileName" paths — the s3Path values from listJobFiles(), e.g. ["my-job/results.csv"] maxSizeMB: How many megabytes a SINGLE file may ride the tool channel as inline content. Default 256 KB. RAISE it (max 50) when your shell has no network access and curl is unavailable; set it to 0 to switch inlining OFF and always receive a downloadUrl, which is what you want when the file is headed for disk. jobName, fileName: DEPRECATED single-file form, equivalent to files=["<jobName>/<fileName>"]. Still accepted so clients holding a cached tool list keep working. Prefer files. Returns: JSON: {"downloadUrl", "downloadType", "count", "totalBytes", "expiresInSeconds", "instructions", "files": [{"s3Path", "size"}]} — or, for one small text file, {"content", "jobName", "fileName", "s3Path", "size", ...} CHECK "error" FIRST here too: a refusal (unknown or unauthorised job, a path that does not exist, a selection over the limits) returns {"error", "hint", ...} with NO "downloadUrl", "count" or "files". For a zip, "zipLayout" says how the members are named: "flat" when every file's path WITHIN its job is unique — any subdirectories are kept, only the "<jobName>/" prefix is dropped — otherwise every member is nested under "<jobName>/". Unzip into a directory (-d) rather than the cwd either way. Security: - Every entry is checked for path traversal, and matching is confined to your own files - Every job named is checked against the backend before anything is served — owning the prefix is not by itself authorization

getJobLogs

ChatGPT
Fetch the output logs for a specific job from S3. This is useful for debugging job failures, checking progress, or understanding what happened during job execution. Args: jobName: The name of the job (e.g., "03-11_10-proteinmpnn-9h0O-canary") maxLines: Maximum number of lines to return from the end of the log (default 500) Returns: The output log contents (last N lines) or error message Examples: - getJobLogs("03-11_10-proteinmpnn-9h0O-canary") - getJobLogs("my-alphafold-job", maxLines=100)

getJobSchema

ChatGPT
Get the detailed parameter schema for a specific job type. Checks both standard tools (DynamoDB) and custom tools (API) to find the schema. Returns the complete schema including all parameter definitions with their types, descriptions, validation rules, and metadata. Args: jobType: Job type name (e.g., "proteinmpnn", "alphafold", "rfdiffusion", or custom tool name) Returns: Complete JSON schema for the job type including: - parameters: full parameter definitions (name, type, description, required, etc.) - displayName: human-readable tool name - description: tool description - categories: tool categories - tags: tool tags - outputTypes: what this tool declares it produces — molecular (pdb, sequence, sdf, smiles) and otherwise (csv, score, cif, ...); a few are compound, like "pdb-list", so match by CONTAINMENT. Chain on the molecular ones: they must cover what the next tool takes as input. Absent means the tool declares nothing (UNKNOWN), not that it produces nothing. - outputs: what the results look like — taskType (generate vs score is what tells you whether the tool creates a molecule or just annotates one), produces (molecular representations the output carries — as a column of the result table OR as a file written alongside it — INCLUDING any echoed from the input, so a scorer can list one), mainCSV, and columns (name, type, description, units). The column names are the metrics to filter or rank results on. Absent when the tool declares no contract. For a tool whose output depends on the task it runs, outputs.byTask gives the per-task contract and is AUTHORITATIVE for the task you set — read it instead of the scalar fields, which summarize across tasks and are NOT guaranteed to describe the task selector's default. Each entry is complete (a task inherits the top-level mainCSV/taskType when it doesn't redeclare them) and carries generates: what that task creates fresh, which is empty for a scoring task whose table still echoes its input. A column carrying a tasks list appears only in those tasks; an UNTAGGED column is simply not task-gated in the declaration, which does not promise every task fills it — read generates for what a task actually produces. outputs.byTaskNote restates this on the response. - custom: true if this is a custom tool (only present for custom tools) Examples: - getJobSchema("alphafold") - getJobSchema("proteinmpnn") - getJobSchema("protein_properties_wmo6g") custom tool

getJobs

ChatGPT
List your jobs (status, timing, score), or fetch one job by name. By default each job's bulky input JSON is OMITTED: for a big batch it dominates the payload and overflows the context. The input blob is named Sequence on the production API and Settings on the legacy API, so both are dropped (whichever a job carries). Set includeSequences=true to keep them, or use getResult()/getJobFile() for a single job's full inputs/outputs. The Score field is retained as a ranking signal. Args: jobName: Return just this one job. batch: Return all jobs in this batch. startKey: Pagination cursor from a previous call (to page past limit). limit: Max jobs to return (default 1000); a startKey is returned if more remain. organization: If true, return all jobs across your organization. includeSubjobs: If true, include batch subjobs (only top-level jobs by default). jobEmail: Return jobs for another member of your organization. includeSequences: If true, keep each job's bulky input JSON (the Sequence/Settings fields, omitted by default). Returns: JSON: {jobs: [...], startKey?, statuses?} for listings, or a single job object when jobName is given.

getMoleculeImport

ChatGPT
Read an existing structure import. Only status=ingested is ready for Jobs. Use moleculeIds as pickerComplex complexId values together with groupId; omit settings.pdbFile. Poll the same importId while queued. Report failed or cancelled imports instead of submitting their inputs.

getPipelineRun

ChatGPT
Get one pipeline run's status and per-step progress. Poll this to follow a run submitted with submitPipeline. Each step reports its own status, how many of its jobs are complete, and outputGroup — the molecules group that step produced. Use getPipelineRunResults(runId) to read those outputs. Args: runId: The run id (the id returned by submitPipeline). Returns: JSON PublicRun: { id, templateId, templateVersion, name, source, status, startedAt, completedAt, inputs, nodeRuns: [{id, nodeId, label, nodeType, status, startedAt, completedAt, outputCount, jobsTotal, jobsComplete, outputGroup}] }. This tool returns the API payload verbatim, so nodeRuns is the key you index — a step's own id is id, and the stable pipeline node id you pass to getPipelineRunResults(node=...) is nodeId. A backend that predates the node-run rename answers with steps: [{..., node}] instead; read nodeRuns or steps and nodeId or node if you must work against both. getPipelineRunResults normalizes this for you — only this passthrough varies.

getPipelineRunResults

ChatGPT
Read a pipeline run's OUTPUTS — the molecules each step produced, with their scores — rather than just its status. Returns every step's molecules, with their scores — which is what you rank and compare on. A step's molecules come from one of two API resources, and WHERE the scores sit differs between them, so read whichever shape you get: group molecules — id in `id`, scores under `metadata`; the step's own outputs — id in complexId, scores at top level in scores. Passed through as they come rather than reshaped here, so the fields match what the docs for each resource say. A step with an outputGroup is normally read from the group, but falls back to its own outputs when the group returns nothing — so do not assume a step's shape from whether outputGroup is set. outputGroup is the molecules group a step MINTED, and a step that produced plenty may still have none: one that enriches its inputs in place (scoring, structure prediction) leaves its molecules in the group they came from, and a filter step's survivors exist only as step outputs. Those steps report outputGroup: null and their molecules are read from the step itself, so a null group no longer means "nothing here". Results appear per step as it finishes, so this is useful before the whole run is complete. A step reports an empty molecules list when it genuinely has not produced anything yet. To page through a step that produced more than limit molecules: call again with node set to that step and cursor set to its nextCursor. Args: runId: The run id. node: Only this step's outputs — the nodeId value from getPipelineRun's nodeRuns. Omit for every step that has produced output. limit: Molecules per step, 1-100 (default 25). Keep it small — molecules carry their sequences, files and full score history. cursor: A nextCursor from a previous call, to fetch the next page. Requires node, since a cursor belongs to one step's group. Returns: JSON: { runId, status, steps: [{node, label, status, outputGroup, molecules[], nextCursor, error?}] }.

getPipelineSchema

ChatGPT
Get the pipeline IR schema and the full authoring guide. Call this BEFORE writing a pipeline graph for submitPipeline/validatePipeline — the IR has rules that are not guessable, and authoring blind reliably produces graphs the API rejects. Returns the complete, uncompressed JSON Schema plus the prose guide. Both are fetched live from the app host, so they always match the deployed validator. The guide covers, among other things: the four node kinds; that there is NO edge list (topology lives inside each node's inputs); that every molecule user_input needs a reference group; that a filter node must either set intersect: true or carry at least one rule; and that residue selections are supplied per-run in the BINDING (residuesByChain), never as a node setting. Returns: JSON: { schemaUrl, guideUrl, schema, guide }. On failure, error plus the two URLs so you can read them another way.

getPipelineTemplate

ChatGPT
Get one pipeline template: its graph, its bindable inputs, and its versions. The inputs array is the important part — it is the manifest of what you must pass as bindings to submitPipeline/validatePipeline. Each entry gives the input node id to key the binding by, whether it takes molecules or a file, the molecule type it expects, its reference chain labels, and any residueFields. A non-empty residueFields means the run MAY take a residuesByChain selection in this input's binding — it does NOT mean one is required. This said REQUIRES, and it is not true: production runs of the rfdiffusion, bindcraft and antibody-boltzgen templates whose manifests declare residueFields finished with no residuesByChain at all, and the entries carry no per-field required flag to tell the two apart. Believing it forces a choice between refusing a runnable template and inventing a selection — and an invented one is not a no-op: it reaches the tool as designed residues / binder hotspots / a binding site, constraining the design to the wrong residues and spending GPU on scientifically wrong output that still looks successful. Do not guess. Call validatePipeline with the bindings you have: if a selection is genuinely required, it comes back as required-field-unset naming the field. Note also that targetsChains is empty on some entries and names a chain outside the input's own chains on others (a de-novo chain the graph creates), so it is not always a usable key for residuesByChain. Args: templateId: The template id (from listPipelineTemplates). version: A version handle like "v2". Omit for the version a default run would use (published, else latest). Returns: JSON PublicTemplate: { id, name, description, isPublished, publishedVersion, version, pipeline (the IR), inputs[], versions[], createdAt, updatedAt }.

getResult

ChatGPT
Retrieve results for a completed job Responses: - 200 (Success): Job results - Content-Type: application/json - Example: ``json "https://s3.amazonaws.com/bucket/job-results.zip" `` - 400: Bad request - 401: Unauthorized - 404: Job not found

importMoleculeFile

ChatGPT
Prepare an uploaded PDB for Protein Solubilization through the existing Molecules API. fileName is the bare filename returned by uploadFile; nested storage paths are not accepted. Returns groupId and importId after commit, without waiting for ingestion or submitting compute. Call getMoleculeImport until status=ingested. Reuse the resulting reference across batch rows that use the same structure.

listAssayTargets

ChatGPT
Search a lab's target list to find a target's id for a binding assay. Read-only. Put the id in the order's settings. The field depends on the lab: - Adaptyv: targetId (one id). - A-Alpha Bio: targetIds (a list of ids). - Ginkgo: targetAntigen (one id, which for Ginkgo is the antigen's name). The assay type's targetsProvider (from listAssayTypes) says which lab's list to search. Needs Assay Portal access: 403 wetlab_access_required otherwise. A 502 targets_unavailable means the lab's list could not be loaded just now; try again shortly. Query Parameters: - provider (Required): The lab whose targets to search, from the assay type's targetsProvider. - search: Text to look for in a target's id, name, aliases or UniProt id, e.g. "PD-L1" or "Q9NZQ7". Not case-sensitive. Searching is much better than paging through the whole list. - limit: How many targets to return, up to 500. Responses: - 200 (Success): The targets that match - Content-Type: application/json - Response Properties: - total: How many targets matched in all. - truncated: True when more targets matched than were returned. Narrow search or raise limit. - Example: ``json { "provider": "string", "targets": [ { "id": "string", "name": "string", "uniprotId": "string" } ], "total": 1 } ` - **400**: provider is missing or not one we offer, or limit is out of range - **401**: Missing or invalid API key - **403**: This account doesn't have Assay Portal access (wetlab_access_required) - **502**: The lab's target list could not be loaded just now (targets_unavailable`)

listAssayTypes

ChatGPT
List the wet-lab assays you can order through Tamarind's Assay Portal, such as binding affinity, binding screens, expression, thermostability and developability. Partner labs (Adaptyv, Ginkgo, A-Alpha Bio) run them on your sequences. Read-only. Start every assay order here. Each assay type gives: - assayType: the id to order with. - modalities: whether it takes antibodies, proteins or both. Send modality on the order when it takes both. - minSequences / maxSequences. - settings: what the order's settings object takes: a name, a type, whether it is required, the options to choose from when there is a fixed set, the default, and list when it takes an array. - targetsProvider: set when the assay needs a target. Look the target up with listAssayTargets(provider=<targetsProvider>). wetLabAccess says whether this account can place orders. When it is false, the order tools answer 403 wetlab_access_required. The user can ask for access at requestAccessUrl. Ordering an assay: 1. listAssayTypes: pick the assay type. 2. listAssayTargets: when the type has a targetsProvider. 3. submitAssay(mode="validate"): check the order. Nothing is sent to a lab. 4. submitAssay(mode="estimate"): optional price and turnaround. This DOES send the sequences to the lab. 5. submitAssay(mode="submit"): place the order once the user has confirmed it. 6. listAssays(assayId=...): follow the order. Once results are in, the answer carries the download links. Query Parameters: - provider: Only list assay types from this lab. Responses: - 200 (Success): The assay types you can order - Content-Type: application/json - Response Properties: - wetLabAccess: Whether this account can place orders. - requestAccessUrl: Where the user can ask for Assay Portal access. - Example: ``json { "assayTypes": [ { "assayType": "adaptyv_affinity", "name": "string", "provider": "string" } ], "wetLabAccess": true, "requestAccessUrl": "string" } `` - 400: That provider isn't one we offer - 401: Missing or invalid API key

listAssays

ChatGPT
Your wet-lab assay orders, newest first, or ONE order (with its result files once the lab has delivered them). Read-only. With assayId: {"assay": {...}}, the other arguments ignored. When the order's resultsAvailable is true, the answer also has results: files (name + download url), complete (false while missingFiles are not downloadable yet) and expiresInSeconds. The links expire: call again for fresh ones rather than saving them. If the files could not be loaded just now, resultsError says why. Without it: {"assays": [...], "nextToken": ...}. While nextToken is not null, call again with it; a page can hold fewer than limit orders and still have more. An order normally goes pending_approval (Tamarind is reviewing it and arranging payment) -> approved -> in_progress -> completed. Check resultsAvailable, not status, to know when results are in. cancellable says whether cancelAssay would work now. Args: assayId: One order to return, with its results when they are in. status: Only orders with this status: pending_quote, pending_approval, approved, in_progress, completed, failed, cancelling, cancelled, rejected or unknown. limit: Orders per page, 1-100 (default 25). nextToken: The previous page's nextToken.

listBenchmarkRuns

ChatGPT
List your benchmark runs, newest first. Requires benchmark access. Returns JSON {items: [runs], nextCursor}. A null nextCursor marks the last page.

listBenchmarks

ChatGPT
Discover your benchmarks or Tamarind's published benchmark data. When asked about Tamarind Benchmarks, published model scores, FoldBench, CoFold Arena, Membrane PPI or POISK, start here with scope="public". This retrieves existing data; it does not create a benchmark or run tools. Use mine (default) or org for custom benchmarks. Returns {items, next}. Public entries have public:<board> ids, source=hosted, readOnly=true and resultSchema. Call getBenchmark for their scoring definitions and getBenchmarkResults for their published leaderboard and scores. Native mine/org listings require custom benchmark access.

listFinetunedModels

ChatGPT
List the finetuned (trained) models you can run: the ones you trained (personalModels) plus those teammates have shared with your organization (organizationModels). Read-only. To RUN one, call submitJob (or submitBatch for many inputs) with: - type = the model's inferenceType (the inference tool that runs it; null means the model has no inference tool, e.g. proteus), - top-level modelId = the model's id (preferred — names are not unique; modelName = its name also works for your own models), - settings = that inference tool's inputs, from getJobSchema(jobType="<inferenceType>"). Only a model whose status is "Available" can be run, and only as its own inferenceType (any other type is refused). To run a teammate's model (one that carries owner), send its id, not its name. To TRAIN a new model, use submitFinetuningRun (list the tools you can finetune with getAvailableModels); the trained model appears here once its job completes. Query Parameters: - type: Optional. Only models trained by this finetuning tool, e.g. "chemprop-finetune" or "plm-finetune" (the model row's type, NOT its inferenceType). An unknown or unavailable tool is answered with a 400 that lists the valid values. - limit: Maximum models per list (personal and organization are each capped at this). A cap, not a page size: personalTruncated and organizationTruncated say whether either list was cut short. Responses: - 200 (Success): The models you can see - Content-Type: application/json - Response Properties: - personalModels: Models you trained. - organizationModels: Models teammates shared with your organization. - personalTruncated: True when personalModels stopped at limit with more of your models unread. Raise limit (type filters the rows already read, so it cannot reach past it). - organizationTruncated: True when organizationModels may be missing models past limit. Raise limit before concluding a teammate's model does not exist (type filters the rows already read, so it cannot reach past it). - Example: ``json { "personalModels": [ "unknown_type" ], "organizationModels": [ "unknown_type" ], "totalCount": 1 } ` - **400**: Invalid type (the body lists the valid types) or invalid limit` - 401: Unauthorized - invalid API key

listJobFiles

ChatGPT
List job output files — across ONE job or MANY, without downloading anything. Answers "what exists?" cheaply: names, sizes and s3Path only — no file contents and no download URLs. This is always the first step, because getJobFile does not search; it fetches the paths you hand it. listJobFiles("my-job") every file in one job listJobFiles("my-job", ".csv") just the CSVs in one job listJobFiles("my-batch-", "-scores.csv") one file across many jobs BOTH arguments accept globs (`, ?, [...]) and match the WHOLE name. fileName defaults to "*", so a bare job name lists everything in it. Pass the s3Path values you want to getJobFile(files=[...]) — one call for the whole set. When your criterion cannot be written as a glob ("the newest ten", "everything after run 28"), filter this result in code and pass the paths you kept. IMPORTANT: the returned s3Path also works directly in submitJob to chain jobs — no need to download and re-upload. Args: jobName: A job name, or a glob over job names (e.g. "my-batch-*"). Put as much LITERAL text as you can before the first wildcard — that prefix is what makes the search cheap. A pattern starting with a wildcard ("*-scores") has to walk every job you own and will usually time out. fileName: Glob over files within each job (default "*" = everything; e.g. "*-scores.csv"). Matches the whole name, and ` spans "/" — ".csv" also matches "seqs/out.csv". Returns: JSON {"count", "bytesListed", "files": [{"jobName", "path", "s3Path", "size", "sizeHuman", "lastModified"}], "hints"}. One job additionally returns "jobName" and "s3Prefix". No contents, no download URLs. CHECK "error" FIRST. A job name with no wildcard is an exact lookup, so an unknown or unauthorised one comes back as {"error", "hint"} with NO "count" and NO "files" — code that reaches straight for "count" dies on a mistyped name. A job name WITH a wildcard is a search and never errors that way; it answers "count": 0. When the request succeeded but matched nothing, "count" is 0 and a singular "hint" replaces "hints". A cross-job search may stop early on a cap; then "truncated" says why, and "count"/"bytesListed" describe only what is listed — narrow jobName and search again. A single job is always listed in full. Examples: - One job: listJobFiles("03-11_10-proteinmpnn-9h0O-canary") - A sweep: listJobFiles("my-batch-", "-scores.csv") - Then fetch: getJobFile(files=["job-a/x.csv", "job-b/y.csv"])

listModalities

ChatGPT
List the biological MODALITIES (molecule types) you can filter tools by. A modality is what KIND of molecule a tool works on — protein, antibody, peptide, small-molecule, nucleic-acid, etc. This is one of the two axes for narrowing the tool catalog (the other is function — see listTags()). Call this BEFORE getAvailableTools to pick a modality, then filter with getAvailableTools(modality="<value>"). Combine with function= to narrow more. Returns: JSON: { modalities: [{ value, label, description?, toolCount }], ... }. Pass value (e.g. "antibody") as the modality filter. toolCount is how many tools you can currently see in that modality.

listMoleculeGroups

ChatGPT
List molecule groups — the way to FIND an existing group to feed a pipeline. A group id from here is the same id a binding takes ({"group": "<id>"}) and the same id a run reports as a step's outputGroup, so a group produced by one run can be fed straight into the next. Rows are summaries: id, name, type, moleculeCount, source, tags, timestamps — no molecules. Use searchMolecules(group=<id>) to see what is inside one. Args: search: Case-insensitive LITERAL substring of the group name — _ and % match themselves, not as wildcards. scope: "mine" (default — groups you created) or "org" (your whole organization's). sort: "recent" (default), "name", or "size". dir: "asc" or "desc". limit: Page size, 1-200 (default 50). Keep it small and follow nextCursor — a full 200-row page costs roughly 19k tokens of context. cursor: nextCursor from a previous page. Returns: JSON: { items: [{id, name, type, moleculeCount, source, tags, status, createdAt, updatedAt}], nextCursor }.

listPipelineRuns

ChatGPT
List pipeline runs. Note that pipeline runs do NOT appear in getJobs() — that endpoint covers single jobs and batches only, so this is the way to see them. Args: status: Filter by run status. templateId: Only runs of this template. owner: "mine" (default) or "org". limit: Page size, 1-200 (default 50). cursor: nextCursor from a previous page. Returns: JSON: { items: [{id, templateId, templateVersion, name, source, status, startedAt, completedAt}], nextCursor }.

listPipelineTemplates

ChatGPT
List saved pipeline templates you can run. Use this to find an existing pipeline instead of authoring a graph from scratch — then read it with getPipelineTemplate() and run it with submitPipeline(templateId=...). Rows are summaries only (no graph). Call getPipelineTemplate for the IR and the list of inputs you must bind. Args: search: Match templates by name. owner: "org" (the DEFAULT — your whole organization's templates, so results include ones you did not create) or "mine" to narrow to your own. isPublished: True for published templates only, False for unpublished. limit: Page size, 1-200 (default 50). cursor: nextCursor from a previous page. Returns: JSON: { items: [{id, name, description, isPublished, versionCount, runCount, createdBy, createdAt, updatedAt}], nextCursor }.

listProjects

ChatGPT
List the projects you can tag jobs with, to resolve a projectTag. Call this when a submission is refused for a missing or invalid project tag and you need more than the capped availableProjects the refusal carries, or when the user names a project and you want its id before submitting. ONLY a project with scope "org" satisfies an organization's "require a project tag" policy. A "personal" project is your own and a "shared" one is someone else's private project you were invited to; submitting with either is refused exactly as if you had sent no tag at all. Returns: JSON { projects: [{ id, name, scope }], isInOrg }. Pass a project's id as projectTag on submitJob / submitBatch, or as project on submitPipeline. id ALWAYS works; a name works only for "org" and "personal" scopes, because a "shared" project lives in another user's partition where names are not unique and are therefore not resolved — sending one comes back "not found". Prefer the id and the distinction stops mattering. When isInOrg is false you have no organization, so every project is reported as "org" and no required-project policy applies.

listTags

ChatGPT
List the FUNCTIONS (a.k.a. tags) you can filter tools by. A function is what a tool DOES — structure-prediction, binder-design, protein-ligand-docking, binding-affinity, etc. This is one of the two axes for narrowing the tool catalog (the other is modality — see listModalities()). Call this BEFORE getAvailableTools to pick a function, then filter with getAvailableTools(function="<value>"). Combine with modality= to narrow more. Returns: JSON: { functions: [{ value, label, description?, toolCount }], ... }. Pass value (e.g. "structure-prediction") as the function filter. toolCount is how many tools you can currently see with that function.

publishPipelineTemplate

ChatGPT
Publish one version of a pipeline template to the user's ORGANIZATION. This shares the template with everyone in the organization, so they can find and run it, and PINS exactly version. Until it is published, a template (for example the one submitPipeline saves from an inline graph) is the user's own, and nobody else in the organization can run it. It spends nothing and runs nothing. Only one version is published at a time: publishing another version of a template that is already published moves the pin to that version, which changes what the whole organization runs. Publishing the version already pinned changes nothing. Ask the user before calling this, and name the template and the version. The platform re-validates the version first: a version that would not run is NOT published (a 422 with per-node diagnostics; fix the graph, save a new version and publish that). Publishing needs the right to publish this template (its owner, an editor or an organization admin); without it the call is refused. Args: templateId: The template id (from listPipelineTemplates, getPipelineTemplate, or the templateId a submitPipeline run reports). version: The version handle to publish, like "v2" (getPipelineTemplate lists the template's versions). Required: there is no default version to publish. Returns: JSON: { templateId, isPublished, publishedVersion } (publishedVersion is the pinned handle, e.g. "v2"). getPipelineTemplate reports the same isPublished and publishedVersion afterwards.

replaceBenchmarkInterfaces

ChatGPT
Replace a dataset's interfaces sheet and set up its chains again. Requires benchmark access. Returns acceptance, not completion. Poll getBenchmarkDataset until complete with a higher version, then inspect finalizeError and problems; refused sheets preserve the old chains. On version_conflict, re-read before editing again. On dataset_busy, wait retryAfter seconds before checking again.

saveAgent

ChatGPT
Save one of the user's agents: a new one, a new version of one, or the Tamarind agent. Changes the user's saved settings: new chats get it, and chats already started keep what they began with. Inside a Tamarind chat the user is asked first, and for the agent that chat runs as they choose where the change lands. To change one, read it with getAgentBuilder first, change only what was asked, send the rest of the definition back unchanged, and pass the version read. Args: definition: {name, description, instructions, capabilities: {key: bool}, subagents: {name: bool}, approvals: {action: "auto"|"ask"}, job_types: [tool names] | null, models: [modelId] | null, pipelines: [templateId] | null, skills: [built-in skill names] | null, custom_skills: [{id, version?}], agent_subagents: [{id, version?}], model, effort, connectors: [{id?, name, url}]}. Only name is required for a new agent. null means every one; a capability or subagent left out stays on. Keys and names come from getAgentBuilder(what="catalog"), ids from what="skills" and what="agents". The Tamarind agent's has no name, description, instructions, custom_skills or connectors, and has settings: {skills: {skillId: bool}, connectors: {connectorId: bool}} instead. What it leaves out, or sets null, follows org_default. agentId: The agent's id (agt_...), or tamarind. Leave it out to create one, as a draft only the user uses until they publish it in the app. expectedVersion: version.version from the getAgentBuilder read (0 for a Tamarind agent never saved). Required with agentId. Returns: JSON { agent, version: {version, definition, ...} }, or for tamarind { default: {settings, agent, version} }.

saveSkill

ChatGPT
Save one of the user's skills: a new personal one, or a new version of one. Changes the user's saved settings: agents keep the version they were saved with, and new chats with the Tamarind agent get this one. Inside a Tamarind chat the user is asked first. To change one, read it with getAgentBuilder(what="skill") first, change only what was asked, and send the rest back unchanged: every file you leave out of files is removed. An imported skill loses its link to the GitHub folder it came from. Args: skillMd: The whole SKILL.md, starting with a --- header giving its name and description. files: The skill's other files, path -> text (not SKILL.md). skillId: The skill's id (skl_...). Leave it out to create one. expectedVersion: version.version from that read. Required with skillId. Returns: JSON { skill: {id, ...}, version: {version, ...} }.

searchMolecules

ChatGPT
Query molecules across every group and run — filter and rank by TOOL SCORE, not just by name. This is the cross-run view. getPipelineRunResults(runId) answers "what did THIS run produce, step by step"; this answers "across everything I have ever run, which molecules score best" — and takes a run's outputGroup as group when you want to narrow back down to one step. Filtering is the point. filter takes repeatable field:operator:value predicates, AND-ed, over metadata fields AND tool scores written as tool.metric: filter=["alphafold.plddt:gt:0.8", "round:eq:2"] Operators: gt, gte, lt, lte, eq, neq, and field:exists (metadata only). sortBy takes the same tool.metric form, so you can rank by a score directly. Molecules are heavy — they carry chains, files and score history — so keep limit small and follow nextCursor. Args: group: Only this group's molecules (a group id, or a step's outputGroup). jobName: Only molecules a job or batch produced or consumed, by name. Names are not unique; every visible match is included. jobId: The same, by id. Pass a batch id, not a child job id. type: Restrict to molecule kinds, e.g. ["protein"], ["small_molecule"]. search: A term. With mode="default" (the default) it matches molecule NAMES. matchedOn says which field hit, and in practice it is always ["name"]: the documented metadata-key and score-metric matching does not fire, so searching for an annotation key returns an empty page with a NULL nextCursor — which per this tool's own contract means "finished, no matches", not "not implemented". To find molecules by an annotation, use filter instead (filter=["my_key:exists"]), which does match metadata. With mode="sequence" it is an amino-acid subsequence. mode: "default" or "sequence". filter: Repeatable field:operator:value predicates (max 32), AND-ed. neq also excludes molecules where the field is absent, so it is not the complement of eq. scope: "mine" (only groups YOU created) or "org" (your whole organization). Defaults to "mine" — EXCEPT when you pass group, where it defaults to "org", because a group id you were given is often a coworker's and "mine" would answer with an empty page. Pass "mine" explicitly to override that. sortBy: "id", "added", "type", "groupName", or a metadata field / tool score (tool.metric, on that tool's best run). WARNING: an unknown field here is IGNORED rather than rejected — the page comes back 200 in the default order with nothing saying the ranking was dropped. Spell it exactly as filter would take it, and sanity-check that the first item really does lead on that metric before acting on the order. dir: "asc" or "desc". limit: Molecules per page, 1-100 (default 25). cursor: nextCursor from the previous page. Returns: JSON: { items[], nextCursor, mode, scanProgress }. EITHER mode may return an EMPTY page while nextCursor is set — that means "keep paging", not "no results"; only a null nextCursor ends the search. In sequence mode scanProgress (0.0-1.0) tracks the scan.

stopBenchmarkRun

ChatGPT
Stop your benchmark run. Requires benchmark access. Returns runId, status and jobsSweepFailed. If jobsSweepFailed is true, some jobs could not be stopped and finish on their own. launch_in_progress means wait retryAfter seconds before retrying. Finished outputs are kept.

stopFeatureExtraction

ChatGPT
Stop an extraction through the normal pipeline stop operation. jobsSweepFailed reports an incomplete job sweep.

stopPipelineRun

ChatGPT
Stop a running pipeline. Steps that already finished keep their outputs; work still in flight is cancelled. Use this rather than cancelBatch — cancelBatch only understands the older pipeline job layout and will not stop one of these runs. Args: runId: The run id to stop. Returns: JSON PublicRun, reflecting the run's state after the stop.

submitAssay

ChatGPT
Check, price or place ONE wet-lab assay order with a partner lab (Adaptyv, Ginkgo, A-Alpha Bio). The same order fields in every mode: mode="validate" (default): check the order. Nothing is created, and the sequences are NOT sent to a lab. Answers valid; when false, error and details say what to fix. Run it until valid before the other modes. mode="estimate": price (USD) and turnaround. Creates nothing, but SENDS THE SEQUENCES TO THE LAB to be priced, so ask the user first. estimatedCostUsd is null for targets priced on request. mode="submit": place a real, paid order. Needs idempotencyKey. Tamarind reviews every order and arranges payment before the lab starts (a new order is pending_approval; nothing is charged here), but some labs receive the sequences at submit. Show the user the assay type, target, sequence count and any estimate, and get their OK first. Workflow: listAssayTypes -> listAssayTargets (when the type has a targetsProvider) -> this tool: validate, estimate (optional), submit -> listAssays(assayId=...) to follow the order and fetch its results. IDEMPOTENCY (submit). Use a new UUID per order. If a submit fails, times out or its outcome is unclear, retry with the SAME key and SAME arguments: you get the original order back (idempotentReplay: true), never a second one. Never reuse a key for a different order (422). Errors carry the platform's code and error, which say what to do; follow them (they name REST routes: GET /assays is listAssays, the Idempotency-Key header is idempotencyKey). In particular: - 409 duplicate_order: nothing was created; a recent order had the same assays and sequence count (duplicateOfOrderId). Ask the user whether they want a second, separately billed order. Only then resend with confirmDuplicate=true and a NEW idempotencyKey. Never set it on your own. - teamNotified: true (e.g. 409 assays_blocked, 502 order_incomplete): do not resubmit; Tamarind will follow up. - 403 wetlab_access_required: the account cannot order yet; the user can ask for access at requestAccessUrl. Requests only ever go to the Tamarind platform (POST https://app.tamarind.bio/api/validate-assay, /estimate-assay, /submit-assay). Args: assayType: From listAssayTypes, e.g. "adaptyv_affinity". mode: "validate" (default), "estimate" or "submit". idempotencyKey: Required for mode="submit": a new UUID for this order (at most 255 characters), reused only to retry it. sequences: Antibodies: "HEAVY:LIGHT" strings (or "HEAVY"), or {"name", "heavy", "light"} objects. Proteins: a string (chains joined with ":"), or {"name", "sequence"} objects. Names and sequences must all differ. Send this or csvFile. modality: "antibody" or "protein"; can be left out when the assay type takes only one. settings: The assay type's settings. A target goes in as targetId (Adaptyv), targetIds (A-Alpha Bio, a list) or targetAntigen (Ginkgo), using the id from listAssayTargets. csvFile: Instead of sequences: a CSV's path in your files (uploadFile it first). Needs columnMapping. columnMapping: The CSV's columns: name, heavy, light (antibodies) or name, sequence (proteins). name: A name for the order (at most 200 characters). notes: For the Tamarind team reviewing it (at most 2000 characters). confirmDuplicate: Only after duplicate_order, and only when the user wants the second order. Returns: JSON with mode. validate: the verdict (valid, error, details, ...). estimate: the estimate. submit: success=true, assay (assayId, status, cancellable, resultsAvailable, ...) and idempotentReplay. A refusal in any mode: success=false, backendStatus and the platform's answer as sent.

submitBatch

ChatGPT
Submit MANY jobs as a SINGLE batch (one tool call, not one per job). Submits the settings you construct to the Tamarind API (POST https://app.tamarind.bio/api/submit-batch). Requests only ever go to the Tamarind platform; the endpoint is fixed and not caller-controlled. ALWAYS prefer this over calling submitJob in a loop. If you are about to submit more than one job of the same type, use submitBatch instead — it is one request, groups the jobs under a shared batch name, and is far cheaper than N separate submissions. But when settings holds exactly ONE entry, call submitJob instead. A one-job batch is pure overhead: the platform writes a batch parent row beside the single child and runs an aggregation pass to wrap it, and nothing is being grouped. Stay here even for a single job when the request needs something submitJob cannot express — it takes only jobName, type and settings: - weightedHoursBudget, a runaway-cost cap. It is enforced off the batch parent row, so a single job without that row has no cap at all. - maxRuntimeSeconds, a per-job timeout. - fromJob / fromFile (+ topN, sequenceField, sharedSettings). Reading the source, parsing it and ranking it all happen HERE, so a chained request cannot be restated as a submitJob call — including when the source turns out to hold a single sequence. Three ways to provide the per-job inputs: 1. fromJob (chaining — RECOMMENDED for ProteinMPNN -> AlphaFold/Chai): Pass a COMPLETED sequence-design job name. This reads that job's generated sequences from its output (filtered_sequences.fa / seqs/*.fa / metrics.csv), and folds EACH sequence as its own job in one batch. Example: submitBatch(batchName="verify-mpnn", type="alphafold", fromJob="proteinmpnn-example-7v3te") 2. fromFile (a fasta or csv of sequences): Pass a workspace filename or a job s3Path (from listJobFiles) to a .fasta/.fa or .csv containing one sequence per record. Each sequence becomes one job. Example: submitBatch(batchName="fold-designs", type="alphafold", fromFile="designs.fasta") 3. settings + jobNames (explicit, full control): Provide an array of per-job settings objects and a matching array of job names. Use this when each job needs different parameters. NAMING RULE. Never reuse batchName for one of the jobNames. The batch is itself a job under that name, so a job sharing it collides and the batch never finishes; the server rejects the submission with 400. The comparison is against the CLEANED name — characters outside [A-Za-z0-9._-] are stripped and whitespace becomes "_", so a batch sent as "my batch" is stored as "my_batch", and that is the value no job may equal. Args: batchName: Unique name for the batch (also the prefix for auto job names). type: Tool to run for EVERY job in the batch (e.g. "alphafold", "chai"). All jobs in a batch use the same tool. Use getJobSchema(type) for params. settings: (mode 3) Array of per-job settings objects. jobNames: (mode 3) Array of job names, same length as settings, and none equal to batchName (see NAMING RULE). For fromJob/fromFile you can omit this — names are auto-generated as "{batchName}-1", "{batchName}-2", ... fromJob: (mode 1) Completed job whose generated sequences to fold. fromFile: (mode 2) Workspace path / job s3Path to a fasta or csv of sequences. sequenceField: Settings field each sequence is placed into (default "sequence" — correct for alphafold/chai/boltz/esmfold). topN: Keep only the top-N sequences (ranked by MPNN/overall_confidence score when available). Omit, or pass <=0, to fold ALL (default). sharedSettings: Settings applied to every generated job (mode 1 & 2), e.g. {"useMSA": true, "numModels": "5"}. maxRuntimeSeconds: Optional per-job timeout (integer seconds, >=1). weightedHoursBudget: Optional budget for the whole batch (number, >=0). projectTag: Organization project to file EVERY job in this batch under — its project id or its name. REQUIRED for orgs that have turned on "require a project tag"; those reject an untagged batch with 400 and a PERSONAL project does not count. The 400 carries availableProjects (id + name), so retry with …

submitFinetuningRun

ChatGPT
Start ONE finetuning (model-training) run. Finetuning trains a model on the user's own data (e.g. a property predictor on a CSV of SMILES + measured values, or a protein language model on labelled sequences). The run is an ordinary job — poll it with getJobs / getJobLogs — and when it completes it registers a MODEL. Submits to the Tamarind API (POST https://app.tamarind.bio/api/finetune). Requests only ever go to the Tamarind platform; the endpoint is fixed and not caller-controlled. Workflow: 1. Find finetuning tools: getAvailableModels() (train with the trainer, e.g. "chemprop-finetune", not the inference tool "chemprop-inference"). 2. Read its settings: getJobSchema(jobType="<model>"). Upload any training files first (uploadFile) and reference them by filename. 3. Call this tool. 4. The trained model appears in listFinetunedModels; it can run once its status is "Available". 5. Run it with submitJob (or submitBatch): type = the model's inferenceType, modelId = the model's id. Several training runs with one tool (a sweep): call submitBatch with the finetune tool as type instead of calling this tool in a loop. Args: model: The finetuning tool to train with — exact, case-sensitive name (e.g. "chemprop-finetune", "plm-finetune"). This is the field submitJob calls type. Use submitJob for ordinary tools: if model is not a finetuning tool (the platform answers "not_a_finetune_tool"), the connector resends it ONCE to POST /submit-job as an ordinary job; endpoint in the result names the route that accepted it. jobName: Name for the run (letters, digits, _ or -; max 100 chars). The trained model takes this name. settings: Training settings for model — see getJobSchema(jobType=model). parentModelId: Optional. Train the next VERSION of an existing model: its id from listFinetunedModels (it must be trained with the same tool). Sent as settings.parentModelId. Tools that do not record lineage refuse it; proteus registers no model. projectTag: Organization project to file the run under — id or name. REQUIRED for orgs that turned on "require a project tag"; the 400 then carries availableProjects to retry with. Returns: JSON: success, jobName (the stored name to poll), model, and the backend response; on refusal an "error" plus any code / availableProjects / hint the platform sent.

submitJob

ChatGPT
Submit ONE job for protein analysis using one of the available tools. Submits the settings you construct to the Tamarind API (POST https://app.tamarind.bio/api/submit-job). Requests only ever go to the Tamarind platform; the endpoint is fixed and not caller-controlled. IMPORTANT: Use this only for a single job. If you are about to submit more than one job (e.g. folding several sequences, scanning variants, or chaining a design job's output into structure prediction), call submitBatch ONCE instead of calling submitJob in a loop. Looping submitJob is slower, ungroupable, and rate-limited. For ProteinMPNN -> AlphaFold/Chai, use submitBatch(fromJob="<mpnn job>", type="alphafold"). Responses: - 200 (Success): Job submitted successfully - 400: Bad request - invalid parameters - 401: Unauthorized - invalid API key - 429: Too many requests - rate limit exceeded

submitPipeline

ChatGPT
Run a multi-tool pipeline. This SPENDS COMPUTE — call validatePipeline on the same graph and bindings first, and only submit once it reports valid:true. Two modes. Pass pipeline (a full IR graph) to author and run in one call: the server saves a template you own, unpublished, and runs it. Or pass templateId to run a template you already have, which is how you re-run without re-authoring the graph. Poll the returned run with getPipelineRun(runId), and read its outputs with getPipelineRunResults(runId). Args: name: Name for the pipeline. In inline mode it names the created template too. Required. bindings: One entry per input node, keyed by the input node's id. Give molecules exactly one way: {"group": "<groupId>"}, or raw values — {"sequences": [...]}, {"smiles": [...]}, {"pdbs": [...]}, {"sdfs": [...]} — and the server creates the group for you (and rolls it back if the submit fails). A file input takes {"file": "<path>"}. Add "residuesByChain": {"A": "1-76"} where a tool needs a residue selection, and "chainMapping" only when your chain IDs differ from the template's reference chains. pipeline: INLINE mode — a full pipeline IR. Call getPipelineSchema() first. Mutually exclusive with templateId. templateId: REFERENCE mode — an existing template to run. version: REFERENCE mode only — a version handle like "v2". Omit for published-then-latest. settings: REFERENCE mode only — per-node overrides {nodeId: {settingKey: value}}, limited to the template's editable settings. runName: An explicit name for THIS run. Omit to derive a unique one from name. project: Organization project id to stamp on the jobs this run creates. idempotencyKey: A client key that makes a retried submit safe. Returns: JSON PublicRun: { id, templateId, templateVersion, name, status, startedAt, completedAt, inputs, steps[] }. id is the runId.

updateMoleculeProperties

ChatGPT
Add or change properties on molecules that already exist, e.g. wet-lab results for a group you imported earlier: up to 200,000 rows in one call, nothing re-imported. Each row names one molecule, by its moleculeId or by its name in groupId (names are unique in a group), and carries the properties to write. Properties are MERGED: a key you send is added or overwritten, keys you leave out are untouched, and an empty cell writes nothing. A value is stored as a number when it plainly is one (the same rule as importMoleculeFile: 007, 1,234 and 12% stay text), so searchMolecules filters and sorts on it and a benchmark reads it as {"property": "<column>"} (or as a comparison's truth) on its next results read, with no rerun. Tool scores can't be overwritten here. A value that doesn't fit a group schema's typed field comes back in rejected with the reason (e.g. "field 'score' expects type float, got 'abc'"). Two sources; pass exactly one: - fileName: a CSV/TSV uploaded with uploadFile (comma or tab detected). keyColumn is the column naming each molecule; a header of moleculeId / molecule_id / id is read as molecule ids, any other (e.g. name, design_id) as names in groupId. When omitted it is the id column if there is one, else name. Every other column is a property, or only columns when given. e.g. name,kd_nM,expression -> groupId=<group>, fileName="wetlab.csv" - rows: inline, for a few hundred: [{"name": "ab1", "properties": {"kd_nM": 3.2}}, ...] or [{"moleculeId": "<id>", "properties": {...}}]. A property set to null is removed. Limits per call: 200,000 rows, 2,000,000 values (rows x property columns), 500 property columns and a 64 MiB file; split a bigger sheet by rows or pass columns. Rows are sent in batches of 5,000, several at once; 100,000 rows take well under a minute. The result counts molecules updated and rows not found, refused (with the reason, e.g. a key that is a tool score) or ambiguous, and lists the first problems by row number. A batch that failed or did not start in time is listed: call again with the same arguments and batches=[...] (sending a batch twice writes the same values). Args: groupId: The group the molecules are in. Required when rows name molecules by name; with it, only that group's molecules are written. fileName: The bare filename returned by uploadFile (.csv, .tsv or .txt). keyColumn: The file's column naming each molecule (see above). columns: Only these columns become properties (default: every column but the key). rows: Inline rows instead of a file. batches: Re-send only these batch numbers (an earlier result's failedBatches/notStartedBatches).

uploadFile

ChatGPT
Upload a local file to your Tamarind file store (up to 200 MB). RECOMMENDED (up to 200 MB) — call with just filename to get a short-lived uploadUrl on mcp.tamarind.bio, then stream your file to it with ONE shell command: curl -T /path/to/<filename> "<uploadUrl>" The bytes go straight from your machine to your store. Afterwards the file appears in getFiles(), the web Database tab, and can be referenced by its BARE filename in submitJob/submitBatch file fields. IF curl FAILS with "could not resolve host" / "network unreachable" / HTTP 000, your MCP client's sandbox is blocking outbound network. The MCP tools keep working (they go through the client, not your shell) — only the upload curl needs egress to the uploadUrl's host (mcp.tamarind.bio in production). The exact host to allow is named in the uploadUrl/instructions you get back; tell the USER to allow that host, then re-run the curl: - Claude Desktop / Claude.ai: Settings -> Capabilities -> "Allow network egress" -> under "Additional allowed domains" add that host - Other MCP clients (e.g. Codex): add that host to the client's network / egress allowlist. FALLBACK (no shell available, or a small file you can't enable egress for): pass the file's bytes inline via content (text, or base64 for binary), up to the 4 MB inline cap. The server writes them directly — no curl, no egress: uploadFile(filename="target.pdb", content=<file text>) uploadFile(filename="model.bcif", content=<base64>, encoding="base64") FLAT FILES ONLY: pass a bare name like "target.pdb" (no "/"). Args: filename: Bare destination name, e.g. "target.pdb". content: FALLBACK only — the file's bytes inline (no curl, up to 4 MB). Leave EMPTY to get an uploadUrl to stream to (recommended). encoding: "text" (default; for text like PDB/CIF/FASTA) or "base64" (for binary or non-UTF8 inline content). contentType: MIME type to store (optional). Returns: JSON. Default: {"uploadUrl", "filename", "instructions", ...}. Inline fallback: {"success": true, "filename", "bytes", "hint"}.

validateBenchmark

ChatGPT
Dry-run a benchmark create or update body. No side effects, no compute. Requires benchmark access. Returns {valid, definition, problems, warnings, estimate}. definition has every inputMap fully resolved, so you can see what was inferred. Each problem has a code (binding_unresolved, binding_ambiguous, binding_type_mismatch, tool_not_found, tool_version_required, evaluator_needs_model, column_not_found, column_not_score, property_not_found, truth_not_designated, direction_required, compare_kind_mismatch, setting_value_invalid, models_fixed, key_reused, ...) and a JSON pointer to the offending field. Fix them and validate again before createBenchmark or updateBenchmark. For an update body the estimate prices the cells it would launch.

validateJob

ChatGPT
Validate job settings BEFORE submitting, so you can catch missing or invalid fields and fix them (or ask the user) instead of submitting and surfacing a 400. Pass the whole set in one call. settings takes a list of settings objects as well as a single one. Every row is validated — nothing is sampled — so do not sample, and do not call this tool once per job. If a list is too large for one request, the answer says so and asks you to split it; split it then, keeping each part as large as it will go. Returns JSON. For a single settings object: { valid, normalized?, error?, ... } For a list: { valid, count, valid_count, results: [ { index, valid, normalized?, error? }, ... ] } valid is the aggregate — true only if EVERY row passed. index is the row's position in the list you sent. HTTP 200 is used for both outcomes — read valid. Read results to tell a bad row from a refused request: a list with one bad row and a list refused as a whole (out of quota, a bad jobNames) both answer valid: false, but only the first carries results. IMPORTANT: only submit settings that came back valid:true WITHOUT a mutatedFields warning. A mutated input means the validator silently dropped disallowed characters (e.g. non-standard residues), so submitting as-is would run the job on ALTERED input — fix the input and re-validate first. For a list this is reported per row, and the aggregate valid is false if ANY row was mutated. Then submit: one settings object with submitJob, a list with submitBatch in a single call. Args: type: Tool name — see getAvailableTools(). settings: One settings object, or a list of them — see getJobSchema(jobType=type). jobName: Optional name for a single job. Pass it when you have one, so a collision with an existing job is reported now rather than at submit time. inputs: Protein Solubilization prepared pickerComplex references (one list per settings row for batches). Jobs checks their structure and ownership at submission. jobNames: Optional names for a list — same length and order as settings. A name repeated within the list is refused.

validatePipeline

ChatGPT
Validate a pipeline run WITHOUT executing or saving anything. ALWAYS call this before submitPipeline — a pipeline run costs real compute, and most authoring mistakes are caught here. Takes the arguments submitPipeline validates: the graph (pipeline or templateId+version), bindings, settings and name. submitPipeline's remaining arguments — runName, project, idempotencyKey — name and tag the run rather than describing it, and the validator does not read them, so passing them here would change nothing. If validationUnavailable comes back, the validator could not be reached and your pipeline was NOT judged — retry a couple of times rather than editing the graph, and if it fails identically every time, report it instead of looping. Returns { valid, errors[] } at HTTP 200 for both outcomes; read valid. Each error carries a stable code, the node it belongs to, the field at fault where there is one, and a message telling you how to fix it. Codes you will actually hit include required-field-unset (often a residue selection that belongs in the binding, not in settings), input-unbound, tool-unknown, setting-invalid, param-out-of-range, chain-incompatible and molecule-class-incompatible (the upstream tool does not produce what the downstream tool consumes). valid: true is NOT a guarantee that submitPipeline will accept the run. Known gaps, measured: it does not confirm the tools exist, and it does not check that a bound molecule group exists or has anything in it. So if submitPipeline rejects a graph this approved, believe submitPipeline — re-validating will not reproduce the error, and the fix is in what it names (usually a tool name or a group id), not in the graph's shape. Fix the reported errors and re-validate until valid is true. Args: name: A name for the pipeline/run. Required. bindings: One entry per input node, keyed by the input node's id. Give molecules exactly one way: {"group": "<groupId>"} for an existing molecule group, or raw values — {"sequences": [...]}, {"smiles": [...]}, {"pdbs": ["<uploadedPath>"]}, {"sdfs": [...]} — and the server creates the group for you. A file input takes {"file": "<path>"}. Add "residuesByChain": {"A": "1-76"} where the template's residueFields ask for one, and "chainMapping" only when your chain IDs differ from the template's reference chains. pipeline: INLINE mode — a full pipeline IR. Call getPipelineSchema() first. Mutually exclusive with templateId. templateId: REFERENCE mode — an existing template to run. version: REFERENCE mode only — a version handle like "v2". settings: REFERENCE mode only — per-node overrides {nodeId: {settingKey: value}}, limited to the settings the template's author marked editable. Returns: JSON: { valid: bool, errors: [{code, severity, node, field, message}] }.

cancelBatch

Claude

cancelJob

Claude

deleteFile

Claude

deleteJob

Claude

getAvailableTools

Claude

getFileStats

Claude

getFiles

Claude

getFolders

Claude

getJobFile

Claude

getJobLogs

Claude

getJobSchema

Claude

getJobs

Claude

getResult

Claude

listJobFiles

Claude

submitBatch

Claude

submitJob

Claude

uploadFile

Claude

validateJob

Claude

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/plugin_asdk_app_6a5fc156fad88191a3977b60131d7391"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/plugin_asdk_app_6a5fc156fad88191a3977b60131d7391)