⚠️ CALL THIS TOOL FIRST every turn, before any other TogoMCP tool.

Returns the v4 Usage Guide, which enforces the empirically-validated workflow:

GATE 0: classify the question (bounded → STEP −1 | open-ended → EXPLORATION).
STEP −1: analyze entities, databases, endpoints (no tools).
STEP  0: find_databases(keywords=[...]) — token-efficient discovery.
STEP  1: specialized search or ncbi_esearch — ground in real IRIs.
STEP  2: get_MIE_file(database) — required before any run_sparql.
STEP  3: run_sparql() — LIMIT 10 first; max 2 consecutive calls, then pivot.
STEP  4: synthesize — each fact once, no meta-commentary.

Why this matters (measured): questions with ≥3 consecutive run_sparql calls score 1.26 points lower than compliant ones; jumping to text search before reading the MIE schema accounts for ~95% of silent SPARQL failures. The guide also documents the controlled category taxonomy used by find_databases() and the EXPLORATION habits (Seed Definition, concierge check, prioritized Next Steps) for open-ended deep dives.

Re-run GATE 0 every turn — prior workflow does not carry forward.

Returns: str: The content of the TogoMCP v4 usage guide.

Get the available SPARQL endpoints for RDF Portal.

Returns: Dict with two keys: - databases: Dict mapping database -> {url, endpoint_name, keyword_search} - endpoints: Dict mapping endpoint_name -> {url, databases}

Run a SPARQL query on an RDF database. Specify database (valid values: uniprot, rhea, pubchem, pdb, chembl, chebi, reactome, ensembl, amrportal, mesh, go, taxonomy, mondo, nando, bacdive, mediadive, clinvar, pubmed, pubtator, ncbigene, medgen, ddbj, glycosmos, supercon, bgee, oma, brenda, hgnc, jpostdb) for single-database queries, or endpoint_name (valid values: sib, pubchem, pdb, ebi, primary, ncbi, ddbj, glycosmos, nims) / endpoint_url for cross-database queries on shared endpoints. Invalid database/endpoint_name values fail immediately with a deterministic error — do not retry.

Get a list of named graphs on a SPARQL endpoint. Virtuoso/OpenLink internal graphs are filtered out. If database is given, graph URIs containing that substring (case-insensitive) are ranked first — useful when the endpoint hosts multiple databases (e.g. SIB hosts UniProt + Rhea + Bgee + OMA). For a database not yet in the registry, pass endpoint_url (or endpoint_name if its parent endpoint is registered) to bypass database validation; database can still be supplied alongside as a ranking hint.

At the start of any task, identify ALL databases needed and call this tool for EACH of them before writing any SPARQL queries. Do not query a database until its MIE file has been read. Get the MIE (Metadata Interoperability Exchange) file containing the ShEx schema, RDF and SPARQL examples of a specific RDF database.

Supplementary: full catalog dump (browse only, no filtering).

Returns every available RDF database with {database, title, description}. Use this only when you need the entire catalog with no filter — for example, to enumerate all databases or to discover what kinds of data exist before you have specific search terms.

For every normal workflow, call find_databases(keywords=[...]) first — that is the canonical entry point. This tool is a supplementary fallback.

Returns: A list of dicts with keys database, title, description.

Database discovery — REQUIRED first step for any TogoMCP workflow.

Always call this BEFORE get_MIE_file() or run_sparql(). Pass any search terms you have (gene, pathway, drug target, variant, organism, disease, enzyme class, etc.) as keywords. Returns 1–3 candidate databases scoped to your terms — much more efficient than browsing the full catalog.

Workflow:

1. find_databases(keywords=[...]) — identify 1–3 relevant databases.

2. get_MIE_file(database) — learn each candidate's schema and SPARQL idioms.

3. run_sparql() — query with the discovered structured properties.

Common keywords to try: "MANE" (Ensembl), "drug targets" (ChEMBL), "clinical variants" (ClinVar), "pathways" (Reactome), "variants" (gnomAD), "ortholog" (OMA), "expression" (Bgee).

If you have no search terms and want to browse the full catalog instead, see list_databases() — that tool is supplementary, not a substitute for this one.

Returns: List of dicts: {database, title, matched_keywords, categories, snippet} (or description when verbose=True). Sorted by number of matched keywords descending, then alphabetically by database name.

Coarse-grained index of database categories with member database names.

Use this when you don't yet have specific keywords — drill down with find_databases(category=...) once you've identified relevant categories.

Returns: Dict mapping category name -> sorted list of database names. Returns an empty dict if no databases have been annotated with categories yet.

Search for a UniProt entity ID by query.

⚠️ Only the search string and limit are accepted. Extra parameters like taxon, organism, reviewed, species, etc. are silently dropped and have no effect — express such filters inside the Solr query string instead (e.g., organism_id:9606 AND reviewed:true).

The search string can be passed as any of: query (canonical), search, term, keyword, keywords, search_term, or name.

Args: query (str): The Solr-style query string for the UniProtKB /search endpoint.

    QUERY SYNTAX:
    - Simple keyword: "rubisco"
    - Field-specific: "field:value"  (e.g., "gene:BRCA1", "protein_name:rubisco")
    - Boolean operators: AND, OR, NOT  (e.g., "gene:TP53 AND organism_id:9606")
    - Grouping with parentheses: "((gene:CTNNB1) AND (taxonomy_id:9606))"
    - Wildcards (* suffix): "gene:PRO*" matches any gene starting with PRO
    - Ranges: "length:[1000 TO 2000]" or open-ended "length:[5000 TO *]"

    KEY QUERY FIELDS:
    Identity / Name:
      accession          UniProt primary accession (e.g., "accession:P04637")
      id                 UniProt entry name / mnemonic (e.g., "id:P53_HUMAN")
      protein_name       Protein name, including synonyms (e.g., "protein_name:rubisco")
      gene               Gene name with wildcard support (e.g., "gene:BRCA*")
      gene_exact         Exact gene name match (e.g., "gene_exact:TP53")
      ec                 Enzyme Commission number (e.g., "ec:1.1.1.1")

    Taxonomy:
      organism_id        NCBI taxonomy ID (e.g., "organism_id:9606" for human,
                         "organism_id:10090" for mouse)
      organism_name      Organism scientific or common name
      taxonomy_id        Taxon ID including all descendants
      lineage            Taxonomic lineage keyword

    Annotation status:
      reviewed           true = Swiss-Prot (manually reviewed),
                         false = TrEMBL (automatically annotated)
                         ALWAYS add "reviewed:true" when seeking high-quality entries.

    Sequence properties:
      length             Sequence length as a range (e.g., "length:[100 TO 500]")
      mass               Molecular mass in Daltons (range supported)
      existence          Protein existence level: 1 (protein), 2 (transcript),
                         3 (homology), 4 (predicted), 5 (uncertain)

    Functional annotation:
      keyword            UniProt keyword name (e.g., "keyword:Kinase")
      keyword_id         UniProt keyword ID (e.g., "keyword_id:KW-0418")
      function           Function free-text annotation
      family             Protein family (e.g., "family:globin")
      organelle          Subcellular organelle (e.g., "organelle:chloroplast")
      cc_subcellular_location  Subcellular location comment

    Cross-references:
      database           Database cross-reference (e.g., "database:PDB")
      xref               Cross-reference ID (e.g., "xref:pdb-1A2B")
      chebi              ChEBI ID (e.g., "chebi:15422")
      interactor         UniProt accession of interacting protein

    Literature:
      lit_author         Author surname (e.g., "lit_author:Smith")
      lit_pubmed         PubMed ID
      lit_doi            DOI

    EXAMPLES (structured queries):
      # Reviewed human TP53 protein
      "gene_exact:TP53 AND organism_id:9606 AND reviewed:true"

      # All human kinases manually reviewed
      "keyword:Kinase AND organism_id:9606 AND reviewed:true"

      # EGFR in human or mouse
      "gene_exact:EGFR AND (organism_id:9606 OR organism_id:10090) AND reviewed:true"

      # Long chloroplast proteins (>= 5000 aa) in any organism
      "organelle:chloroplast AND length:[5000 TO *]"

      # Proteins with PDB structures involved in apoptosis
      "database:PDB AND keyword:Apoptosis AND organism_id:9606 AND reviewed:true"

      # Proteins encoded by gene names starting with "PIK3"
      "gene:PIK3* AND organism_id:9606 AND reviewed:true"

limit (int): The maximum number of results to return. Default is 20.

Returns: str: TSV-formatted results with columns: accession, protein_name, organism_name.

Search for ChEMBL ID by query.

The search string can be passed as any of: query (canonical), search, term, keyword, keywords, search_term, or name.

Returns: str: A JSON-formatted string containing the search results.

Search for a biological TARGET (protein/receptor/enzyme) in ChEMBL.

⚠️ DO NOT use this tool to look up drugs, compounds, or molecules by name. For drug/compound/molecule names (e.g., "sorafenib", "imatinib", "aspirin"), use search_chembl_molecule instead.

This tool searches for biological entities that drugs act upon — proteins, protein complexes, nucleic acids, organisms, tissues, and cell lines. "Target" here means drug target, NOT "the thing I am looking up".

Only the search string and limit are supported. The search string can be passed as any of: query (canonical), search, term, keyword, keywords, search_term, or name.

Args: query (str): Search query string referring to a biological target. Examples: - Target name (e.g., "Thrombin", "EGFR", "Dopamine receptor") - Gene name (e.g., "BRCA1", "TP53") - UniProt accession (e.g., "P00734") - Organism name (e.g., "Homo sapiens") limit (int, optional): Maximum number of results to return. Defaults to 20.

Returns: dict: Dictionary containing: - 'total_count' (int): Total number of matching targets found - 'results' (list): List of target dictionaries, each containing: - 'chembl_id' (str): ChEMBL target identifier (e.g., "CHEMBL1824") - 'name' (str): Preferred target name - 'organism' (str): Organism name (e.g., "Homo sapiens") - 'type' (str): Target type (e.g., "SINGLE PROTEIN", "PROTEIN COMPLEX") - 'score' (float): Relevance score for the search query

Example: >>> results = await search_chembl_target("EGFR human", limit=5) >>> print(f"Found {results['total_count']} targets") >>> for target in results['results']: ... print(f"{target['chembl_id']}: {target['name']} ({target['organism']})")

Output:
Found 15 targets
CHEMBL203: Epidermal growth factor receptor (Homo sapiens)

Target Types: - SINGLE PROTEIN: Individual protein target - PROTEIN COMPLEX: Multi-protein complex - PROTEIN FAMILY: Group of related proteins - NUCLEIC-ACID: DNA/RNA targets - TISSUE: Tissue-level target - CELL-LINE: Cell line target - ORGANISM: Whole organism target

Raises: httpx.HTTPError: If the API request fails

Search for a DRUG / COMPOUND / MOLECULE by name or structure in ChEMBL.

✅ Use this tool for drug, compound, or molecule names (e.g., "sorafenib", "imatinib", "aspirin", "Gleevec"). ⚠️ For biological targets (proteins, receptors, enzymes, genes such as EGFR, BRCA1, TP53), use search_chembl_target instead.

Molecules in ChEMBL are small-molecule drugs, drug candidates, and bioactive compounds — including approved drugs, clinical candidates, and research compounds.

Only the search string and limit are supported. The search string can be passed as any of: query (canonical), search, term, keyword, keywords, search_term, or name.

Args: query (str): Search query string referring to a drug or compound. Examples: - Generic or brand drug name (e.g., "Aspirin", "Gleevec", "Paracetamol") - Research compound name - Synonyms or alternative names - SMILES notation (chemical structure string) - InChI or InChI Key limit (int, optional): Maximum number of results to return. Defaults to 20.

Returns: dict: Dictionary containing: - 'total_count' (int): Total number of matching molecules found - 'results' (list): List of molecule dictionaries, each containing: - 'chembl_id' (str): ChEMBL molecule identifier (e.g., "CHEMBL25") - 'name' (str): Preferred molecule name (may be None for some compounds) - 'score' (float): Relevance score for the search query

Example: >>> results = await search_chembl_molecule("aspirin", limit=5) >>> print(f"Found {results['total_count']} molecules") >>> for molecule in results['results']: ... print(f"{molecule['chembl_id']}: {molecule['name']} (score: {molecule['score']})")

Output:
Found 3 molecules
CHEMBL25: Aspirin (score: 23.5)
CHEMBL1456: Acetylsalicylic acid derivative (score: 12.3)

Use Cases: - Finding ChEMBL IDs for known drugs or compounds - Discovering molecules with similar names - Searching for bioactive compounds by structure (using SMILES/InChI) - Identifying research compounds and clinical candidates

Note: - Some molecules may not have a preferred name and 'name' field will be None - Higher scores indicate better matches to the query - For structure-based searches, use SMILES or InChI notation

Raises: httpx.HTTPError: If the API request fails

Get a PubChem compound ID

Args: Compound name example: "resveratrol"

Returns: PubChem Compound ID in the JSON format

Get compound attributes from PubChem RDF

Args: PubChem Compound ID example: "445154"

Returns: Compound attributes in the JSON format

Search for PDBj entry information by keywords.

Args: db (str): The database to search in. Allowed values are: - "pdb" (Protein Data Bank, protein structures) - "cc" (Chemical Component Dictionary, chemical components or small molecules in PDB) - "prd" (BIRD, Biologically Interesting Reference Molecule Dictionary, mostly peptides). query (str): Query string, any keywords that can be used to search for PDB entries. Accepts aliases: search, term, keyword, keywords, search_term, name. limit (int): The maximum number of results to return. Default is 20. Must be in [0, 500].

Note: The PDBj search hits multiple fields (title, authors, keywords, citation metadata), not just the title. An entry can appear even if its title does not contain the query. Always verify relevance against the returned name/title before relying on a hit.

Returns: str: A JSON-formatted string containing the search results.

Search for MeSH ID by query.

Args: query (str): The query string to search for. Accepts aliases: search, term, keyword, keywords, search_term, name. limit (int): The maximum number of results to return. Default is 10.

Returns: str: A JSON-formatted string containing the search results.

Search the Reactome knowledgebase using keyword search.

Args: query: The search query string (e.g., "apoptosis", "TP53", "cell cycle"). Accepts aliases: search, term, keyword, keywords, search_term, name. species: Filter by species. Must be the scientific name (e.g., "Homo sapiens", "Mus musculus"). Numeric NCBI taxon IDs like "9606" are rejected here (this tool raises ValueError) because the Reactome API silently ignores them AND can degrade co-occurring filters (e.g. types). Accepts a single string or a list of strings. types: Filter by entity types. Accepts a single string (e.g., "Pathway") or a list (e.g., ["Pathway", "Reaction", "Complex"]). rows: Per-category result cap. Reactome clusters results by entity type (cluster=true), so rows=30 returns up to 30 hits per type, not 30 hits total. To bound the total, constrain types to a single value.

Returns: List of results with 'id', 'name', and 'type' fields. Example: [ {'id': 'R-HSA-109581', 'name': 'Apoptosis', 'type': 'Pathway'}, {'id': 'R-HSA-204981', 'name': '14-3-3epsilon...', 'type': 'Reaction'} ]

Example: >>> results = search_reactome("apoptosis", rows=5) >>> for entry in results: ... print(f"{entry['type']:10} {entry['id']}: {entry['name']}")

>>> # Filter by type
>>> pathways = [r for r in results if r['type'] == 'Pathway']

Raises: httpx.HTTPError: If the API request fails.

Search Rhea database for biochemical reactions using keyword search.

Args: query (str): Search query string. Examples: - "ATP" - find reactions involving ATP - "glucose" - find reactions with glucose - "uniprot:*" - reactions with UniProt annotations - "" - retrieve all reactions Accepts aliases: search, term, keyword, keywords, search_term, name. limit (int, optional): Maximum number of results. Defaults to 100.

Returns: List[Dict[str, str]]: List of reactions, each containing: - 'rhea_id': Reaction identifier (e.g., "RHEA:10000") - 'equation': Reaction equation text

Example: >>> results = search_rhea_entity("ATP", limit=5) >>> for reaction in results: ... print(f"{reaction['rhea_id']}: {reaction['equation']}")

Discover all available ID conversion routes between databases.

⚡ PLANNING TOOL — Call this EARLY when a question involves 2+ databases that are on DIFFERENT SPARQL endpoints and you need to map IDs between them.

Returns a map of all source→target database pairs that TogoID can convert. Use this to plan your cross-database strategy BEFORE attempting SPARQL joins or manual ID lookups.

Common conversion routes include: - ncbigene ↔ uniprot (Gene IDs to/from protein accessions) - uniprot ↔ pdb (Protein accessions to/from 3D structure IDs) - ncbigene ↔ ensembl_gene (NCBI Gene to/from Ensembl gene IDs) - chembl_target ↔ uniprot (Drug targets to/from protein accessions) - ncbigene ↔ hgnc (Gene IDs to/from HGNC symbols) - pubchem_compound ↔ chembl_compound (Compound IDs across databases)

When to use: - Question references 2+ databases on different SPARQL endpoints - You need to bridge identifiers (e.g., "find UniProt proteins for these NCBI Gene IDs") - Before writing complex multi-step SPARQL to join databases manually

When NOT to use: - Both databases share a SPARQL endpoint (use a single SPARQL query) - You only need data from one database - NCBI esearch can already cross-reference what you need

Returns: Dictionary mapping database pairs to their relationship metadata. Each entry shows source, target, and the nature of the link.

Check if a specific ID conversion route exists and get its details.

Use this to verify that a particular source→target conversion is available before calling convertId. Also reveals the nature of the relationship (e.g., "encoded by", "has structure", "is target of").

Args: source: Source database key (e.g., 'uniprot', 'ncbigene', 'chembl_target') target: Target database key (e.g., 'pdb', 'ensembl_gene', 'hgnc')

Returns: List of relationship objects with: - forward: relationship label from source to target - reverse: relationship label from target to source - description: explanation of the link

Example: >>> getRelation('ncbigene', 'uniprot') # Shows: ncbigene → uniprot via "encoded by" relationship

>>> getRelation('uniprot', 'pdb')
# Shows: uniprot → pdb via "has structure" relationship

List all databases registered in TogoID with their ID formats.

Returns configuration for every dataset TogoID knows about, including:

• label: Human-readable database name

• regex: Pattern for validating IDs (helps you check if you have the right ID format before converting)

• prefix: URI prefix for linked data

• examples: Sample IDs you can use to test conversions

Useful for: - Discovering which databases are available for ID conversion - Checking the expected ID format (e.g., UniProt accession vs entry name) - Finding example IDs to test with countId before bulk conversion

Returns: Dictionary mapping dataset keys (e.g., 'uniprot', 'ncbigene', 'pdb') to their configuration objects.

Get configuration for a specific database in TogoID.

Retrieves detailed metadata about a single dataset, including its ID format, URI prefix, example IDs, and available annotations.

Args: dataset: Dataset key (e.g., 'uniprot', 'ncbigene', 'pdb', 'chembl_target', 'ensembl_gene', 'hgnc', 'pubchem_compound')

Returns: Dictionary with: - label: Human-readable name - regex: ID validation pattern (use to verify your IDs are correctly formatted) - prefix: URI prefixes for linking - examples: Sample IDs (use with countId to test before bulk conversion) - annotations: Available annotation types for this dataset

Get human-readable descriptions for all databases in TogoID.

Returns names, descriptions (in English and Japanese), and organization info for each registered database. Useful for understanding what each database contains when planning cross-database queries.

Returns: Dictionary keyed by dataset name with description metadata.

Convert identifiers from one database to another.

Maps IDs between biological databases — e.g., NCBI Gene IDs to UniProt accessions, or UniProt accessions to PDB structure IDs.

IMPORTANT WORKFLOW: 1. First call getAllRelation() or getRelation() to verify the conversion route exists 2. Optionally call countId() to check how many IDs will convert 3. Then call convertId() with your IDs

Args: ids: Source IDs. Accepts either a list of strings (e.g., ["672", "675", "7157"]) or a comma-separated string ("672,675,7157"). Examples: "672,675,7157" (NCBI Gene IDs), "P38398,P04637" (UniProt) route: Comma-separated pair of dataset keys: 'source,target'. Examples: - 'ncbigene,uniprot' (Gene → Protein) - 'uniprot,pdb' (Protein → 3D Structure) - 'ncbigene,ensembl_gene' (NCBI Gene → Ensembl Gene) - 'chembl_target,uniprot' (Drug Target → Protein) - 'uniprot,chembl_target' (Protein → Drug Target) - 'ncbigene,hgnc' (Gene → HGNC symbol) Multi-hop routes are also supported: - 'ncbigene,uniprot,pdb' (Gene → Protein → Structure) limit: Maximum number of results (default 10000) offset: Pagination offset for large result sets

Returns: List of [source_id, target_id] pairs. Example: [["672", "P38398"], ["675", "O15129"], ...]

Common use cases: - Bridging databases on different SPARQL endpoints - Mapping gene IDs to protein accessions for UniProt SPARQL queries - Finding PDB structures for a set of proteins - Identifying ChEMBL drug targets for a list of genes

Check how many of your IDs can be converted before doing bulk conversion.

A lightweight pre-check: tells you how many source IDs have mappings in the target database WITHOUT actually returning the mapped IDs. Use this to: - Verify your IDs are in the correct format - Estimate result size before a large convertId call - Check if a conversion route works for your specific IDs

Args: source: Source database key (e.g., 'ncbigene', 'uniprot') target: Target database key (e.g., 'uniprot', 'pdb') ids: Source IDs to check. Accepts either a list of strings or a comma-separated string (e.g., ["672", "675"] or "672,675").

Returns: Dictionary with: - source count: number of input IDs recognized - target count: number of target IDs found

Example: >>> countId('ncbigene', 'uniprot', '672,675,7157') # Returns: {"source": 3, "target": 5} # (3 genes map to 5 UniProt entries — some genes have multiple proteins)

Search NCBI databases using E-utilities esearch API.

⚠️ CRITICAL FOR COMPREHENSIVE RESULTS ⚠️ ALWAYS use NCBI field tags for Gene, ClinVar, and similar databases! Without field tags, you may miss 70-80% of relevant results.

MANDATORY FIELD TAGS FOR GENE DATABASE: • [Organism] - Taxonomic filtering (e.g., "Homo sapiens[Organism]", "Archaea[Organism]") • [Gene Name] - Gene symbols (e.g., "TP53[Gene Name]", "nifH[Gene Name]") • [All Fields] - Broad keyword search (e.g., "nitrogenase[All Fields]")

IMPACT OF FIELD TAGS (Gene Database): • Without field tags: ~300 results (20-30% recall) ❌ • With field tags: ~1,300 results (100% recall) ✅ • Performance loss: Missing field tags = 70-80% data loss!

Args: database: NCBI database name (alias: db). Supported values: - "gene" or "ncbigene": NCBI Gene database ⚠️ FIELD TAGS CRITICAL - "taxonomy": NCBI Taxonomy (organism information) - "clinvar": ClinVar (genetic variants) ⚠️ FIELD TAGS CRITICAL - "medgen": MedGen (medical genetics concepts) - "mesh": MeSH (Medical Subject Headings) - "pubmed": PubMed (biomedical literature) - "pccompound": PubChem Compound - "pcsubstance": PubChem Substance - "pcassay": PubChem BioAssay query: Search query with NCBI field tags and boolean operators (alias: term) max_results: Maximum number of results to return (default: 20) start_index: Starting index for pagination (default: 0) sort_by: Optional sort order (e.g., "relevance", "pub_date" for PubMed) search_field: Optional specific field to search in db: Alias for database. term: Alias for query.

Returns: Formatted search results with database-specific IDs

Examples - GENE DATABASE (CRITICAL): ✅ CORRECT (finds ~1,300 archaeal nifH genes, 100% recall): database="gene" query="Archaea[Organism] AND (nifH[Gene Name] OR nitrogenase[All Fields])"

❌ WRONG (finds only ~300 genes, 23% recall):
   database="gene"
   query="archaea AND nifH"
   Problem: Missing [Organism] and [Gene Name] field tags!

✅ CORRECT (human genes):
   database="gene"
   query="Homo sapiens[Organism] AND TP53[Gene Name]"

❌ WRONG (incomplete results):
   query="human AND TP53"

Examples - OTHER DATABASES: MeSH: database="mesh", query="asthma[MeSH Terms]" PubMed: database="pubmed", query="CRISPR[Title/Abstract] AND gene editing" Taxonomy: database="taxonomy", query="Escherichia coli[Scientific Name]" ClinVar: database="clinvar", query="BRCA1[Gene Name] AND pathogenic[Clinical Significance]" PubChem: database="pccompound", query="aspirin[All Fields]"

Learn more: https://www.ncbi.nlm.nih.gov/books/NBK3837/

List all supported NCBI databases with descriptions and example queries.

Returns: Formatted list of available databases

Fetch summary information for given IDs using esummary. Useful for getting detailed info after esearch.

Args: database: NCBI database name (alias: db) ids: IDs to fetch summaries for. Accepts either a list of strings (e.g., ["123", "456"]) or a comma-separated string ("123,456"). db: Alias for database.

Returns: Parsed JSON response with summary data

Fetch full records using efetch. Returns actual data (sequences, records, etc.)

Args: database: NCBI database name (alias: db) ids: IDs to fetch. Accepts either a list of strings (e.g., ["123", "456"]) or a comma-separated string ("123,456"). rettype: Return type (xml, fasta, gb, etc.) retmode: Return mode (text, xml, json where applicable) db: Alias for database.

Returns: Response text in requested format