Render a structure-search report as a styled, self-contained HTML page.

Call this LAST, after the searches and rcsb_get_* calls that produce the values shown in the report. Supply facts only: the page is rendered from a fixed server-side template, so do not write HTML yourself and do not rewrite what this tool returns.

Key fields of report: title: page heading describing the search. api_calls: one per Search/Data/Sequence-Coordinates call, using the editor object the tool returned VERBATIM. Resolver and discovery tools have no editor link — pass label and tool_name only. result_type: what your ids ARE — "entry" for PDB entry ids (4HHB, the default) or "ligand" for chemical component ids (ATP). It must match the ids you send: a mismatch resolves nothing, and every derived value comes back empty. results: the identifiers you are reporting, in the order you want them ranked, each {"id": ..., "evidence": {...}}. Evidence has two fields: grounds (the tool-returned value the match rests on) and optional interpretation (your own reading of it). Splitting them is what stops your inference from being read as something the archive returned. data_usage: ordered narrative of how each call shaped the final set; each item's body is plain prose — your own account of how you worked.

Returns: RenderReportResult with EITHER a url or html (never both), plus template_version. Prefer url — it is a self-contained link that renders the report on demand; deliver it to the user as-is. html is only returned as a fallback; write it to a .html file.

Resolve a free-text molecular function, biological process, or cellular component / location (e.g. kinase activity, ATP binding, DNA repair, apoptosis, signal transduction, mitochondrial membrane, nucleus) to Gene Ontology (GO) terms, so you can run precise GO-based PDB searches instead of keyword guessing.

Use this when a request involves what a protein DOES or where it acts — "proteins that / are involved in / participate in / are responsible for ...", "localized to / located in ...". Resolve the phrase to a GO id here, then search by it — see the resolver guidance in the server instructions for the attribute path and lineage semantics.

Args: query: Free-text function / process / location, e.g. "kinase activity", "DNA repair". namespace: Optional GO aspect to restrict to. Omit to search all three. limit: Max GO terms to return. with_pdb_counts: If true (default), annotate each term with pdb_entry_count (PDB entries carrying it, via annotation_lineage.id).

Returns: {query, namespace, count, terms:[{id, name, aspect, pdb_entry_count?}]}.

Resolve a free-text protein domain, family, or fold (e.g. SH2 domain, immunoglobulin fold, zinc finger, beta-barrel, WD40 repeat, kinase domain) to InterPro entries, for precise InterPro-based PDB searches instead of keyword guessing.

Use this whenever a request references a protein DOMAIN, FAMILY, or fold — "structures containing / with a ", "-containing proteins", "members of the family". Resolve the phrase to an InterPro accession (IPRxxxxxx) here, then search by it — see the resolver guidance in the server instructions for the attribute path and lineage semantics.

Args: query: Free-text domain/family name, e.g. "SH2 domain", "immunoglobulin". entry_type: Optional InterPro type filter. Omit to return all types. limit: Max entries to return. with_pdb_counts: If true (default), annotate each entry with pdb_entry_count (PDB entries carrying it).

Returns: {query, entry_type, count, entries:[{id, name, type, pdb_entry_count?}]}.

Resolve a free-text enzyme, enzyme class, or catalyzed reaction (e.g. alcohol dehydrogenase, protease, kinase, DNA polymerase, hydrolase, oxidoreductase) to Enzyme Commission (EC) numbers, for precise EC-based PDB searches instead of keyword guessing.

Use this when a request references an enzyme, enzyme class, or reaction — including "enzymes that catalyze / break down / degrade / synthesize / hydrolyze / phosphorylate ...". Resolve the phrase to an EC number here, then search by it — see the resolver guidance in the server instructions for the attribute path and lineage semantics.

Args: query: Free-text enzyme / reaction, e.g. "alcohol dehydrogenase", "protein kinase". limit: Max EC numbers to return. with_pdb_counts: If true (default), annotate each with pdb_entry_count (PDB entries carrying it, via rcsb_ec_lineage.id).

Returns: {query, count, enzymes:[{ec, name, pdb_entry_count?}]}.

Resolve a free-text disease, disorder, syndrome, or condition (e.g. diabetes, cancer, Alzheimer disease, cystic fibrosis) to MONDO ontology ids, for precise disease-based PDB searches instead of keyword guessing.

Use for ANY request mentioning a disease/disorder/syndrome/condition — "structures involved in / associated with / linked to ", "proteins implicated in ". Resolve the phrase to a MONDO id here, then search by it — see the resolver guidance in the server instructions for the attribute path and lineage semantics.

Args: query: Free-text disease / condition, e.g. "cystic fibrosis", "breast cancer". limit: Max MONDO terms to return. with_pdb_counts: If true (default), annotate each with pdb_entry_count (PDB entries carrying it, via annotation_lineage.id).

Returns: {query, count, diseases:[{id, name, pdb_entry_count?}]}.

Resolve a free-text organism, common name, or clade (e.g. human, mouse, baker's yeast, Escherichia coli, mammals, bacteria, primates) to NCBI Taxonomy ids, for precise taxonomy-based PDB searches instead of keyword guessing.

Use when a request restricts structures by SOURCE ORGANISM or any higher taxon — a common name you want as a canonical taxon ("human", "fruit fly"), or a CLADE, which a plain name search cannot expand. Resolve the phrase to a taxon id here, then search by it — see the resolver guidance in the server instructions for the attribute path, lineage semantics and the id-typing gotcha.

Args: query: Free-text organism / clade / common name, e.g. "human", "mammals", "E. coli". limit: Max taxa to return. with_pdb_counts: If true (default), annotate each taxon with pdb_entry_count (PDB entries from it or any organism beneath it, via taxonomy_lineage.id) — this also disambiguates a species from its strains.

Returns: {query, count, taxa:[{tax_id, scientific_name, common_name, rank, pdb_entry_count?}]}.

Search the PDB by free-text keywords (e.g. "CRISPR Cas9", "hemoglobin"), optionally refined with structured attribute filters.

Best for broad or exploratory keyword lookups. Pass attributes to AND/OR the keyword with structured conditions (organism, resolution, method, dates, ...) in one query. When a request has NO keyword (only attributes), use rcsb_search_by_attribute; when it resolves to a clear attribute/value, prefer structured search (call rcsb_list_pdb_search_attributes for the exact path — more precise, avoids spurious keyword matches). For a sequence, structure, chemical or motif match, use the matching rcsb_search_by_* tool (each also takes attributes).

BEFORE keyword-searching a biological CONCEPT (disease/function/domain/enzyme/organism), resolve it to an ontology id and filter on the annotation instead — see the resolver and assembly/multimer guidance in the server instructions. Matching spans ALL text annotations, so judge each hit yourself; a high score is text-relevance, NOT biological importance — never tell the user one hit is better than another because its score is higher.

Args: query: Free-text terms matched (case-insensitively) against all text annotations. Quote a phrase to require adjacency (e.g. '"DNA polymerase"'); separate words narrow the results; trailing '' is a prefix wildcard. AND/OR/NOT are NOT boolean operators here. attributes: Optional structured conditions combined with the keyword — AttributeFilter {attribute, operator, value, negation?, case_sensitive?} (see rcsb_search_by_attribute / rcsb_list_pdb_search_attributes for paths and operators). logical_operator: Combine the keyword with the attribute conditions (default "and"). return_type: What to return (default "entry"); see the "Return types and fetching details" note in the server instructions. limit: Max number of hits to return (1-100). offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call, for an explicit "ALL ..." request. Ignores limit and omits paging; can't be combined with offset (the Search API rejects pagination here); refused above 10000 hits — narrow, aggregate with facets, or page. include_computed_models: Also search computed structure models (AlphaFold etc.). chemical: Set True when attributes target chemical-component attributes (the text_chem service; usually pair with return_type="mol_definition"). facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). sort_by: Attribute path to order the hits by; omit to sort by relevance score. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/ dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set. group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; hits are ids only — batch them into rcsb_get_entries (or the rcsb_get_ tool matching return_type). all_hits/facets response variants: see the server instructions.

Discover the RCSB PDB Search schema: attribute paths, value types, and operators.

Call this FIRST when a request resolves to a clear attribute and value but you don't know the exact path; pick the attribute here, then use it in rcsb_search_by_attribute (or as an attributes entry on any rcsb_search_*).

Args: query: Optional case-insensitive keyword to filter the catalog. Matched as a LITERAL SUBSTRING against the attribute path and description, so pass ONE keyword ("resolution", "comp_id"), not a phrase — a multi-word query only matches where those exact words are adjacent in a description. Omit to return everything. schema: Which catalog — "structure" (~675 attrs: entry/entity/assembly/instance) or "chemical" (~57 attrs: chemical-component). See the server instructions for how to search chemical attributes.

Returns: {count, match_mode, attributes, note?}. attributes holds {attribute, type, operators, description} records — the RCSB/PDB attribute path (e.g. "rcsb_entry_info.resolution_combined"), its value type (string/number/integer/date), the operators it supports (exact_match, greater, range, exists, ...), and a human-readable description. match_mode is "exact" (the query matched), "none" (nothing matched — read note, the query shape is the usual cause), or "all" (query omitted, whole catalog).

Search by one or more structured attribute conditions combined with a single AND/OR — preferred over rcsb_search_fulltext whenever the request resolves to clear attribute(s) and value(s). NEVER invent, guess, or infer attributes. If you don't know a path or its operators, call rcsb_list_pdb_search_attributes first. All conditions share ONE logical_operator — NESTED boolean groups are not supported.

For a biological concept, resolve it to an ontology id first and filter on the matching annotation (see the resolver guidance in the server instructions). If a resolver returns no usable id, or a concept/annotation filter yields no hits, fall back to rcsb_search_fulltext for the concept. (For ordinary constraints — resolution, organism, dates — an empty result is a valid answer: report it, don't keyword-search instead.)

Example ("human X-ray structures better than 2 A"): attributes=[ {"attribute": "rcsb_entity_source_organism.ncbi_scientific_name", "operator": "exact_match", "value": "Homo sapiens"}, {"attribute": "exptl.method", "operator": "exact_match", "value": "X-RAY DIFFRACTION"}, {"attribute": "rcsb_entry_info.resolution_combined", "operator": "less", "value": 2.0}, ] Single-condition examples: a released-after-date filter -> {"attribute": "rcsb_accession_info.initial_release_date", "operator": "greater", "value": "2024-01-01T00:00:00Z"}; has any ligand (no value) -> {"attribute": "rcsb_nonpolymer_entity.pdbx_description", "operator": "exists"}.

Args: attributes: One or more AttributeFilter conditions, each {attribute, operator, value, negation?, case_sensitive?}. Operators are TYPE-SPECIFIC (strings use exact_match/in or contains_words/contains_phrase; numbers/dates use greater/ greater_or_equal/less/less_or_equal/equals/range; any type supports exists). A numeric value may be a number or a numeric string; a range value is a {from, to, include_lower, include_upper} object (bounds EXCLUSIVE unless the include flags are true). See rcsb_list_pdb_search_attributes for paths/operators. logical_operator: Combine the conditions with "and" (default) or "or". return_type: What to return (default "entry"); see the "Return types and fetching details" note in the server instructions. E.g. return_type="entry" with a ligand attribute finds the structures that contain it. limit: Max hits (1-100). offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call (for an explicit "ALL ..." request); ignores limit, can't be combined with offset, and is refused above 10000 hits. group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. chemical: Set True for chemical-component attributes (paths from rcsb_list_pdb_search_attributes(schema="chemical"), e.g. "chem_comp.formula_weight"). Switches to the text_chem service; usually pair with return_type="mol_definition". facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). sort_by: Attribute path to order the hits by. A pure attribute filter is a boolean match, so hits otherwise come back in near-arbitrary order — set this for "best resolution first", "newest first", etc. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set.

Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; hits are ids only — batch them into rcsb_get_entries (or the rcsb_get_* tool matching return_type). The per-hit score is near-uniform for a pure attribute filter and carries NO biological meaning — don't rank hits by it. all_hits/facets response variants: see the server instructions.

Find PDB polymer entities similar to a given sequence (MMseqs2, BLAST-like).

Args: sequence: The query sequence in one-letter code. sequence_type: "protein", "dna", or "rna". identity_cutoff: Minimum sequence identity as a fraction 0-1 (e.g. 0.3 = 30%). evalue_cutoff: Maximum E-value to report. return_type: What to return (default "polymer_entity"); see the "Return types and fetching details" note in the server instructions. limit: Max hits (1-100). Returns polymer_entity IDs like "4HHB_1" — fetch their details with rcsb_get_polymer_entities. offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call (for an explicit "ALL ..." request); ignores limit, can't be combined with offset, and is refused above 10000 hits. Ignored when facets is set. attributes: Optional structured filters AND/OR-combined with this match — a list of AttributeFilter {attribute, operator, value, negation?, case_sensitive?} (e.g. restrict to an organism or resolution). See rcsb_search_by_attribute / rcsb_list_pdb_search_attributes for paths and operators. logical_operator: Combine this match and the attribute conditions with "and" (default) or "or". facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. sort_by: Attribute path to order the hits by, replacing the default similarity ordering (each hit's score is still returned); omit to keep it. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set.

Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; with facets, instead returns {total_count, facets, editor}.

Search PDB chemical components by structure (SMILES/InChI) or formula.

Args: value: A SMILES/InChI string (query_type="descriptor") or a molecular formula like "C8H9NO2" (query_type="formula"). query_type: "descriptor" (default) or "formula". descriptor_type: "SMILES" or "InChI" (descriptor queries only). match_type: Graph/fingerprint criterion for descriptor queries, one of: graph-exact, graph-strict, graph-relaxed (default), graph-relaxed-stereo (whole-molecule matches, strict->relaxed = stricter->looser); the sub-struct-graph-* variants of each (substructure search); or fingerprint-similarity (similar molecules). match_subset: Formula queries only — match formulas that merely contain the requested atoms. return_type: What to return (default "mol_definition" = the chemical component); see the "Return types and fetching details" note in the server instructions. limit: Max hits (1-100). offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call (for an explicit "ALL ..." request); ignores limit, can't be combined with offset, and is refused above 10000 hits. Ignored when facets is set. attributes: Optional structured filters AND/OR-combined with this match — a list of AttributeFilter {attribute, operator, value, negation?, case_sensitive?} (e.g. restrict to an organism or resolution). See rcsb_search_by_attribute / rcsb_list_pdb_search_attributes for paths and operators. logical_operator: Combine this match and the attribute conditions with "and" (default) or "or". facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. sort_by: Attribute path to order the hits by, replacing the default score ordering (each hit's score is still returned); omit to keep it. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set.

Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; with facets, instead returns {total_count, facets, editor}.

Find structures with a similar 3D shape to a reference PDB structure.

Args: entry_id: Reference PDB entry, e.g. "4HHB". assembly_id: Use this biological assembly as the reference (e.g. "1"). Defaults to assembly "1" when neither assembly_id nor asym_id is given. asym_id: Use this single chain as the reference instead (mutually exclusive with assembly_id). return_type: What to return (defaults to "assembly" for an assembly reference or "polymer_instance" for a chain reference); see the "Return types and fetching details" note in the server instructions. limit: Max hits (1-100). offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call (for an explicit "ALL ..." request); ignores limit, can't be combined with offset, and is refused above 10000 hits. Ignored when facets is set. attributes: Optional structured filters AND/OR-combined with this match — a list of AttributeFilter {attribute, operator, value, negation?, case_sensitive?} (e.g. restrict to an organism or resolution). See rcsb_search_by_attribute / rcsb_list_pdb_search_attributes for paths and operators. logical_operator: Combine this match and the attribute conditions with "and" (default) or "or". facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. sort_by: Attribute path to order the hits by, replacing the default shape-similarity ordering (each hit's score is still returned); omit to keep it. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set.

Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; with facets, instead returns {total_count, facets, editor}.

Find polymers containing a short sequence motif (PROSITE / regex / simple).

Args: pattern: The motif, e.g. "C-x(2,4)-C-x(3)-[LIVMFYWC]-x(8)-H-x(3,5)-H" (prosite), "C..H[LIVF]" (regex), or "NXS" (simple wildcards). pattern_type: "prosite" (default), "regex", or "simple". sequence_type: "protein" (default), "dna", or "rna". return_type: What to return (default "polymer_entity"); see the "Return types and fetching details" note in the server instructions. limit: Max hits (1-100). offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call (for an explicit "ALL ..." request); ignores limit, can't be combined with offset, and is refused above 10000 hits. Ignored when facets is set. attributes: Optional structured filters AND/OR-combined with this match — a list of AttributeFilter {attribute, operator, value, negation?, case_sensitive?} (e.g. restrict to an organism or resolution). See rcsb_search_by_attribute / rcsb_list_pdb_search_attributes for paths and operators. logical_operator: Combine this match and the attribute conditions with "and" (default) or "or". facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. sort_by: Attribute path to order the hits by, replacing the default score ordering (each hit's score is still returned); omit to keep it. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set.

Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; with facets, instead returns {total_count, facets, editor}.

Find structures containing a 3D STRUCTURAL MOTIF — a geometric arrangement of specific residues — like the one in a reference structure.

This is geometry-based and DIFFERENT from rcsb_search_by_structure (whole-shape similarity) and from rcsb_search_by_seqmotif (sequence pattern). Use it for catalytic triads, binding sites, metal-coordination geometries, etc.

Args: entry_id: Reference PDB entry defining the motif, e.g. "2MNR". residue_ids: 2-10 residues defining the motif, each a dict {"label_asym_id": , "label_seq_id": , "struct_oper_id"?: }. IMPORTANT: these are the mmCIF label identifiers (the internal numbering), which often DIFFER from the author residue numbers seen in papers/the PDB site. If you only have author numbering, resolve the label_asym_id/label_seq_id first (e.g. via rcsb_get_polymer_entity_instances) — author numbers give wrong/no hits. Example (enolase catalytic residues): [{"label_asym_id":"A","label_seq_id":162}, {"label_asym_id":"A","label_seq_id":193}, {"label_asym_id":"A","label_seq_id":219}] backbone_distance_tolerance: Backbone distance tolerance in Å, integer 0-3 (default 1). side_chain_distance_tolerance: Side-chain distance tolerance in Å, integer 0-3 (default 1). angle_tolerance: Angle tolerance in multiples of 20°, integer 0-3 (default 1). rmsd_cutoff: Maximum RMSD of accepted hits (default 2.0). atom_pairing_scheme: ALL, BACKBONE, SIDE_CHAIN (default), or PSEUDO_ATOMS. motif_pruning_strategy: NONE or KRUSKAL (default). return_type: What to return (default "assembly"); see the "Return types and fetching details" note in the server instructions. limit: Max hits (1-100). offset: Number of hits to skip, for paging; pass the response's next_offset back with the same query to fetch the next page. all_hits: Return the COMPLETE result set in one call (for an explicit "ALL ..." request); ignores limit, can't be combined with offset, and is refused above 10000 hits. Ignored when facets is set. attributes: Optional structured filters AND/OR-combined with this match — a list of AttributeFilter {attribute, operator, value, negation?, case_sensitive?} (e.g. restrict to an organism or resolution). See rcsb_search_by_attribute / rcsb_list_pdb_search_attributes for paths and operators. logical_operator: Combine this match and the attribute conditions with "and" (default) or "or". facets: Optional aggregation specs to return a breakdown / distribution instead of hits (see the faceting note in the server instructions for the spec). group_by, group_by_ranking: Collapse redundant polymer_entity hits into clusters, one representative each (needs return_type="polymer_entity") — see the grouping note in the server instructions. sort_by: Attribute path to order the hits by, replacing the default score ordering (each hit's score is still returned); omit to keep it. Only SORTABLE attributes work: those listing exact_match (strings) or equals (numbers/dates) in rcsb_list_pdb_search_attributes; full-text-only attributes (e.g. struct.title) and return_type="mol_definition" are rejected. sort_direction: "asc" (default) or "desc"; applies only when sort_by is set.

Returns: {total_count, returned, offset, has_more, next_offset, hits:[{id, score}], editor}; with facets, instead returns {total_count, facets, editor}.

Discover the fields available on a Sequence Coordinates object, from the live schema.

The Sequence Coordinates analogue of rcsb_describe_data_object, with the same shape: the rcsb_seqcoord_* tools return a compact default selection; use this to find what else you can request via their fields= argument. Every path it returns is verified against the live schema, so it is safe to pass to fields= directly.

Browse a level (default), drill in / scope with into, or raise max_depth to flatten the tree into dotted paths and filter with query. This schema is small and only 3 levels deep (~20-31 fields per object), so max_depth=3 returns an object in full in ONE call: rcsb_describe_seqcoord_object("alignments", max_depth=3) -> pick paths -> call rcsb_seqcoord_alignments(..., fields="target_alignments{ ... }").

Each returned field has path (dotted, ready for fields=), kind ("scalar" leaf or "object"), type, list (whether it's a list), and description (when present).

Args: object_key: A Sequence Coordinates root field. (alignments and group_alignments share the SequenceAlignments type; the annotation roots share SequenceAnnotations.) into: Optional dot-path of nested object field(s) to scope to, e.g. "target_alignments" or "features.feature_positions". query: Optional case-insensitive keyword, matched against each field's path (relative to the scope) and its description. max_depth: How many levels to walk (1-6, default 1 = this level only). The schema bottoms out at 3.

Returns: {object_key, graphql_type, path, query, max_depth, field_count, fields:[{path, kind, type, list, description}], truncated?, note?}.

Cross-reference a sequence across PDB, UniProt, and NCBI, with aligned ranges.

This is the tool for "which X identifiers correspond to this sequence?" across databases — including NCBI. The RCSB Data API only cross-references UniProt, so use THIS tool for NCBI RefSeq protein / genome mappings (and PDB<->UniProt too). The returned target_alignments[].target_id values are the mapped identifiers in the to_ref system, each with its aligned regions.

Examples: - "What NCBI proteins map to PDB entity 4HHB_1?" query_id="4HHB_1", from_ref="PDB_ENTITY", to_ref="NCBI_PROTEIN" - "Which PDB entities correspond to UniProt P69905?" query_id="P69905", from_ref="UNIPROT", to_ref="PDB_ENTITY"

Args: query_id: The sequence id, in the from_ref system's format — UNIPROT "P69905", NCBI_PROTEIN "NP_000508", NCBI_GENOME "NC_000016", PDB_ENTITY "4HHB_1" (entry_entityNumber), PDB_INSTANCE "4HHB.A" (entry.asym_id). PDB ids must be ENTITY-level, never a bare entry: for a whole entry, first get its polymer entity ids (4HHB -> 4HHB_1, 4HHB_2) and query each one. from_ref: Reference system of query_id. to_ref: Reference system to map onto. seq_range: Optional [begin, end] (1-based) to restrict the query region. fields: Optional GraphQL selection to override the default.

Fetch positional sequence annotations (features) for one sequence.

Args: query_id: The sequence id, e.g. "4HHB_1" (PDB_ENTITY) or "P69905" (UNIPROT). reference: Reference system query_id is given in. sources: Annotation provenance — which source(s) to pull features from. seq_range: Optional [begin, end] (1-based) to restrict the region. filters: Optional list of {field, operation, source?, values} filter dicts, where field is TARGET_ID or TYPE and operation is CONTAINS or EQUALS. fields: Optional GraphQL selection to override the default.

Fetch alignments among the members of a sequence group.

Args: group: How the group is defined. group_id: The group id, e.g. "P69905" (a UniProt accession) for MATCHING_UNIPROT_ACCESSION. filter_terms: Optional list of target ids to restrict the group members. fields: Optional GraphQL selection to override the default.

Fetch annotations across the members of a sequence group.

Args: group: How the group is defined. group_id: The group id, e.g. "P69905" for MATCHING_UNIPROT_ACCESSION. sources: Annotation provenance — which source(s) to pull features from. summary: If true, return a positional summary aggregated across the group (group_annotations_summary) instead of per-member annotations. filters: Optional filter dicts (see rcsb_seqcoord_annotations). fields: Optional GraphQL selection to override the default.

Discover the fields available on a Data API object, from the live GraphQL schema.

Use this to find exactly what to request in a rcsb_get_* tool's fields= argument. The rcsb_get_* default selections are compact summaries, but the underlying GraphQL types have far more (e.g. CoreEntry has ~100 fields). Every path it returns is verified against the live schema, so it is safe to pass to fields= directly.

Two ways to use it, both returning dotted paths ready for fields=:

• BROWSE a level (default, max_depth=1): list one object's own fields, then drill into a nested one with into. Workflow: rcsb_describe_data_object("entries") -> spot a nested object such as "rcsb_entry_info" -> rcsb_describe_data_object("entries", into="rcsb_entry_info") to list its leaves.

• SEARCH by keyword: raise max_depth (e.g. 3) and pass query to flatten the object's whole tree — including nested and cross-object paths like "pubmed.rcsb_pubmed_abstract_text" — and keep only matching fields. Combine them: into scopes the walk, so into="rcsb_polymer_entity", max_depth=2 searches just that sub-tree (cheaper and more focused than flattening from the root).

Each returned field has:

• path: dotted path from the object root, ready to use in fields=

• kind: "scalar" (a leaf you can select directly) or "object" (drill in, or select with a sub-selection)

• type: the field's GraphQL type name

• list: whether the field returns a list

• description: schema description, when present

Args: object_key: Which object to describe — the key matching the rcsb_get_* tool. into: Optional dot-path of nested object field(s) to scope to, e.g. "rcsb_entry_info" or "polymer_entities.rcsb_polymer_entity". query: Optional case-insensitive keyword, matched against each field's path (relative to the scope) and its description, e.g. "resolution", "abstract", "organism". max_depth: How many levels to walk (1-6, default 1 = this level only). Depth 2 reaches e.g. "pubmed.rcsb_pubmed_abstract_text"; depth 3 reaches "polymer_entities.rcsb_polymer_entity.pdbx_description". Deeper is slower on a cold cache; prefer a query (and into) over a broad deep walk.

Returns: {object_key, graphql_type, path, query, max_depth, field_count, fields:[{path, kind, type, list, description}], truncated?, note?}. When the result set is capped, truncated is true and note explains how to narrow it.

Fetch metadata for one or more PDB entries (title, method, resolution, size, dates, and primary citation).

The response also lists the entry's component ids under rcsb_entry_container_identifiers — use these to drill into the structure. They are bare numbers; compose them with the entry id to call the matching rcsb_get_* tool: polymer_entity_ids/non_polymer_entity_ids "N" -> "_N" (rcsb_get_polymer_entities / rcsb_get_nonpolymer_entities); assembly_ids "N" -> "-N" (rcsb_get_assemblies).

Args: entry_ids: 4-character PDB entry codes, e.g. ["4HHB", "1MBN"]; pass a one-element list for a single entry. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "struct.title"); discover/verify paths with rcsb_describe_data_object("entries") (see the server instructions).

Fetch polymer entities (protein/nucleic-acid molecules).

Default fields: description, length, weight, and source organism.

Args: entity_ids: entry + entity number, e.g. ["4HHB_1"] — exactly what rcsb_search_by_sequence returns. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_polymer_entity.pdbx_description"); discover/verify paths with rcsb_describe_data_object("polymer_entities") (see the server instructions).

Fetch non-polymer (ligand/cofactor) entities, e.g. ["4HHB_3"].

Default fields: description, weight, copy count, and the bound chemical component ID. Use rcsb_get_chem_comps for the chemistry of that component.

Args: entity_ids: entry + entity number, e.g. ["4HHB_3"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_nonpolymer_entity.pdbx_description"); discover/verify paths with rcsb_describe_data_object("nonpolymer_entities") (see the server instructions).

Fetch branched (carbohydrate / oligosaccharide) entities, e.g. ["5FMB_2"].

Default fields: description, weight, copy count, branch type, and component count.

Args: entity_ids: entry + entity number, e.g. ["5FMB_2"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_branched_entity.pdbx_description"); discover/verify paths with rcsb_describe_data_object("branched_entities") (see the server instructions).

Fetch polymer entity instances (individual chains), e.g. ["4HHB.A"] (entry.asym_id).

Default fields: the entry/entity/chain identifiers and modeled-residue count.

Args: instance_ids: entry.asym_id (chain), e.g. ["4HHB.A"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_polymer_instance_info.modeled_residue_count"); discover/verify paths with rcsb_describe_data_object("polymer_entity_instances") (see the server instructions).

Fetch non-polymer entity instances (individual bound ligands), e.g. ["4HHB.E"].

Default fields: the entry/entity/chain identifiers, bound component id, and author seq id.

Args: instance_ids: entry.asym_id, e.g. ["4HHB.E"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_nonpolymer_entity_instance_container_identifiers.comp_id"); discover/verify paths with rcsb_describe_data_object("nonpolymer_entity_instances") (see the server instructions).

Fetch branched entity instances (individual glycan chains), e.g. ["5FMB.C"].

Default fields: the entry/entity/chain identifiers.

Args: instance_ids: entry.asym_id (glycan chain), e.g. ["5FMB.C"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_branched_entity_instance_container_identifiers.asym_id"); discover/verify paths with rcsb_describe_data_object("branched_entity_instances") (see the server instructions).

Fetch biological assemblies, e.g. ["4HHB-1"] (entry-assembly).

Default fields: composition counts and oligomeric state.

Args: assembly_ids: entry-assembly, e.g. ["4HHB-1"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_assembly_info.polymer_entity_instance_count"); discover/verify paths with rcsb_describe_data_object("assemblies") (see the server instructions).

Fetch assembly interfaces, e.g. ["1BMV-1.1"] (entry-assembly.interface).

Default fields: buried area, character, composition, residue count.

Args: interface_ids: entry-assembly.interface, e.g. ["1BMV-1.1"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_interface_info.interface_area"); discover/verify paths with rcsb_describe_data_object("interfaces") (see the server instructions).

Fetch chemical components / ligands by their short codes, e.g. ["HEM", "ATP"].

Default fields: name, formula, weight, type, SMILES, InChIKey.

Args: comp_ids: chemical-component short codes, e.g. ["HEM", "ATP"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "chem_comp.name"); discover/verify paths with rcsb_describe_data_object("chem_comps") (see the server instructions).

Fetch entry groups (clusters of related entries) by group ID.

Default fields: group name, description, member count, and member ids.

Args: group_ids: entry-group ids, e.g. ["G_1002266"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_group_info.group_name"); discover/verify paths with rcsb_describe_data_object("entry_groups") (see the server instructions).

Fetch polymer entity groups (e.g. sequence clusters), e.g. ["85_70"].

Default fields: group name, description, member count, and member ids.

Args: group_ids: sequence-cluster group ids, e.g. ["85_70"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_group_info.group_name"); discover/verify paths with rcsb_describe_data_object("polymer_entity_groups") (see the server instructions).

Fetch non-polymer entity groups (clusters of related ligands) by group ID.

Default fields: group name, description, member count, and member ids.

Args: group_ids: non-polymer entity group ids, e.g. ["ATP"]. Unknown IDs are returned under "not_found". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_group_info.group_name"); discover/verify paths with rcsb_describe_data_object("nonpolymer_entity_groups") (see the server instructions).

Fetch the UniProt record RCSB maps to an accession, e.g. "P69905".

Default fields give a functional snapshot: accession(s), entry name, protein and gene names, EC number, the UniProt function comment, source organism, and keywords (which often summarize biology directly, e.g. "ATP-binding", "Viral attachment to host entry receptor").

RCSB's UniProt integration is rich — fields can also pull the heavier annotation sets (kept out of the default because they can run to hundreds of entries): rcsb_uniprot_annotation (GO terms, InterPro, disease associations), rcsb_uniprot_feature (domains, sites, binding sites, sequence variants), and rcsb_uniprot_external_reference.

Args: uniprot_id: a UniProt accession, e.g. "P69905". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_uniprot_protein.name"); discover/verify paths with rcsb_describe_data_object("uniprot") (see the server instructions).

Fetch the PubMed record for a citation by its integer ID, e.g. 6726807.

Default fields: PubMed Central ID, DOI, abstract text.

Args: pubmed_id: integer PubMed ID, e.g. 6726807. fields: Optional GraphQL selection replacing the curated default (e.g. rcsb_pubmed_doi); discover/verify paths with rcsb_describe_data_object("pubmed") (see the server instructions).

Fetch provenance/method metadata for a grouping, e.g. "provenance_sequence_identity".

Default fields: the aggregation method/type and provenance id.

Args: group_provenance_id: a provenance token, e.g. "provenance_sequence_identity". fields: Optional GraphQL selection replacing the curated default (e.g. "rcsb_group_aggregation_method.type"); discover/verify paths with rcsb_describe_data_object("group_provenance") (see the server instructions).