davila7
Query STRING API for protein-protein interactions (59M proteins, 20B interactions). Network analysis, GO/KEGG enrichment, interaction discovery, 5000+ species, for systems biology.
bunx add-skill davila7/claude-code-templates -s string-databaseLoading…
STRING is a comprehensive database of known and predicted protein-protein interactions covering 59M proteins and 20B+ interactions across 5000+ organisms. Query interaction networks, perform functional enrichment, discover partners via REST API for systems biology and pathway analysis.
This skill should be used when:
The skill provides:
scripts/string_api.py) for all STRING REST API operationsreferences/string_reference.md) with detailed API specificationsWhen users request STRING data, determine which operation is needed and use the appropriate function from scripts/string_api.py.
string_map_idsConvert gene names, protein names, and external IDs to STRING identifiers.
When to use: Starting any STRING analysis, validating protein names, finding canonical identifiers.
Usage:
from scripts.string_api import string_map_ids
# Map single protein
result = string_map_ids('TP53', species=9606)
# Map multiple proteins
result = string_map_ids(['TP53', 'BRCA1', 'EGFR', 'MDM2'], species=9606)
# Map with multiple matches per query
result = string_map_ids('p53', species=9606, limit=5)
Parameters:
species: NCBI taxon ID (9606 = human, 10090 = mouse, 7227 = fly)limit: Number of matches per identifier (default: 1)echo_query: Include query term in output (default: 1)Best practice: Always map identifiers first for faster subsequent queries.
string_network)Get protein-protein interaction network data in tabular format.
When to use: Building interaction networks, analyzing connectivity, retrieving interaction evidence.
Usage:
from scripts.string_api import string_network
# Get network for single protein
network = string_network('9606.ENSP00000269305', species=9606)
# Get network with multiple proteins
proteins = ['9606.ENSP00000269305', '9606.ENSP00000275493']
network = string_network(proteins, required_score=700)
# Expand network with additional interactors
network = string_network('TP53', species=9606, add_nodes=10, required_score=400)
# Physical interactions only
network = string_network('TP53', species=9606, network_type='physical')
Parameters:
required_score: Confidence threshold (0-1000)
network_type: 'functional' (all evidence, default) or 'physical' (direct binding only)add_nodes: Add N most connected proteins (0-10)Output columns: Interaction pairs, confidence scores, and individual evidence scores (neighborhood, fusion, coexpression, experimental, database, text-mining).
string_network_image)Generate network visualization as PNG image.
When to use: Creating figures, visual exploration, presentations.
Usage:
from scripts.string_api import string_network_image
# Get network image
proteins = ['TP53', 'MDM2', 'ATM', 'CHEK2', 'BRCA1']
img_data = string_network_image(proteins, species=9606, required_score=700)
# Save image
with open('network.png', 'wb') as f:
f.write(img_data)
# Evidence-colored network
img = string_network_image(proteins, species=9606, network_flavor='evidence')
# Confidence-based visualization
img = string_network_image(proteins, species=9606, network_flavor='confidence')
# Actions network (activation/inhibition)
img = string_network_image(proteins, species=9606, network_flavor='actions')
Network flavors:
'evidence': Colored lines show evidence types (default)'confidence': Line thickness represents confidence'actions': Shows activating/inhibiting relationshipsstring_interaction_partners)Find all proteins that interact with given protein(s).
When to use: Discovering novel interactions, finding hub proteins, expanding networks.
Usage:
from scripts.string_api import string_interaction_partners
# Get top 10 interactors of TP53
partners = string_interaction_partners('TP53', species=9606, limit=10)
# Get high-confidence interactors
partners = string_interaction_partners('TP53', species=9606,
limit=20, required_score=700)
# Find interactors for multiple proteins
partners = string_interaction_partners(['TP53', 'MDM2'],
species=9606, limit=15)
Parameters:
limit: Maximum number of partners to return (default: 10)required_score: Confidence threshold (0-1000)Use cases:
string_enrichment)Perform enrichment analysis across Gene Ontology, KEGG pathways, Pfam domains, and more.
When to use: Interpreting protein lists, pathway analysis, functional characterization, understanding biological processes.
Usage:
from scripts.string_enrichment import string_enrichment
# Enrichment for a protein list
proteins = ['TP53', 'MDM2', 'ATM', 'CHEK2', 'BRCA1', 'ATR', 'TP73']
enrichment = string_enrichment(proteins, species=9606)
# Parse results to find significant terms
import pandas as pd
df = pd.read_csv(io.StringIO(enrichment), sep='\t')
significant = df[df['fdr'] < 0.05]
Enrichment categories:
Output columns:
category: Annotation database (e.g., "KEGG Pathways", "GO Biological Process")term: Term identifierdescription: Human-readable term descriptionnumber_of_genes: Input proteins with this annotationp_value: Uncorrected enrichment p-valuefdr: False discovery rate (corrected p-value)Statistical method: Fisher's exact test with Benjamini-Hochberg FDR correction.
Interpretation: FDR < 0.05 indicates statistically significant enrichment.
string_ppi_enrichment)Test if a protein network has significantly more interactions than expected by chance.
When to use: Validating if proteins form functional module, testing network connectivity.
Usage:
from scripts.string_api import string_ppi_enrichment
import json
# Test network connectivity
proteins = ['TP53', 'MDM2', 'ATM', 'CHEK2', 'BRCA1']
result = string_ppi_enrichment(proteins, species=9606, required_score=400)
# Parse JSON result
data = json.loads(result)
print(f"Observed edges: {data['number_of_edges']}")
print(f"Expected edges: {data['expected_number_of_edges']}")
print(f"P-value: {data['p_value']}")
Output fields:
number_of_nodes: Proteins in networknumber_of_edges: Observed interactionsexpected_number_of_edges: Expected in random networkp_value: Statistical significanceInterpretation:
string_homology)Retrieve protein similarity and homology information.
When to use: Identifying protein families, paralog analysis, cross-species comparisons.
Usage:
from scripts.string_api import string_homology
# Get homology between proteins
proteins = ['TP53', 'TP63', 'TP73'] # p53 family
homology = string_homology(proteins, species=9606)
Use cases:
string_version)Get current STRING database version.
When to use: Ensuring reproducibility, documenting methods.
Usage:
from scripts.string_api import string_version
version = string_version()
print(f"STRING version: {version}")
Use case: Analyze a list of proteins from experiment (e.g., differential expression, proteomics).
from scripts.string_api import (string_map_ids, string_network,
string_enrichment, string_ppi_enrichment,
string_network_image)
# Step 1: Map gene names to STRING IDs
gene_list = ['TP53', 'BRCA1', 'ATM', 'CHEK2', 'MDM2', 'ATR', 'BRCA2']
mapping = string_map_ids(gene_list, species=9606)
# Step 2: Get interaction network
network = string_network(gene_list, species=9606, required_score=400)
# Step 3: Test if network is enriched
ppi_result = string_ppi_enrichment(gene_list, species=9606)
# Step 4: Perform functional enrichment
enrichment = string_enrichment(gene_list, species=9606)
# Step 5: Generate network visualization
img = string_network_image(gene_list, species=9606,
network_flavor='evidence', required_score=400)
with open('protein_network.png', 'wb') as f:
f.write(img)
# Step 6: Parse and interpret results
Use case: Deep dive into one protein's interactions and partners.
from scripts.string_api import (string_map_ids, string_interaction_partners,
string_network_image)
# Step 1: Map protein name
protein = 'TP53'
mapping = string_map_ids(protein, species=9606)
# Step 2: Get all interaction partners
partners = string_interaction_partners(protein, species=9606,
limit=20, required_score=700)
# Step 3: Visualize expanded network
img = string_network_image(protein, species=9606, add_nodes=15,
network_flavor='confidence', required_score=700)
with open('tp53_network.png', 'wb') as f:
f.write(img)
Use case: Identify and visualize proteins in a specific biological pathway.
from scripts.string_api import string_enrichment, string_network
# Step 1: Start with known pathway proteins
dna_repair_proteins = ['TP53', 'ATM', 'ATR', 'CHEK1', 'CHEK2',
'BRCA1', 'BRCA2', 'RAD51', 'XRCC1']
# Step 2: Get network
network = string_network(dna_repair_proteins, species=9606,
required_score=700, add_nodes=5)
# Step 3: Enrichment to confirm pathway annotation
enrichment = string_enrichment(dna_repair_proteins, species=9606)
# Step 4: Parse enrichment for DNA repair pathways
import pandas as pd
import io
df = pd.read_csv(io.StringIO(enrichment), sep='\t')
dna_repair = df[df['description'].str.contains('DNA repair', case=False)]
Use case: Compare protein interactions across different organisms.
from scripts.string_api import string_network
# Human network
human_network = string_network('TP53', species=9606, required_score=700)
# Mouse network
mouse_network = string_network('Trp53', species=10090, required_score=700)
# Yeast network (if ortholog exists)
yeast_network = string_network('gene_name', species=4932, required_score=700)
Use case: Start with seed proteins and discover connected functional modules.
from scripts.string_api import (string_interaction_partners, string_network,
string_enrichment)
# Step 1: Start with seed protein(s)
seed_proteins = ['TP53']
# Step 2: Get first-degree interactors
partners = string_interaction_partners(seed_proteins, species=9606,
limit=30, required_score=700)
# Step 3: Parse partners to get protein list
import pandas as pd
import io
df = pd.read_csv(io.StringIO(partners), sep='\t')
all_proteins = list(set(df['preferredName_A'].tolist() +
df['preferredName_B'].tolist()))
# Step 4: Perform enrichment on expanded network
enrichment = string_enrichment(all_proteins[:50], species=9606)
# Step 5: Filter for interesting functional modules
enrichment_df = pd.read_csv(io.StringIO(enrichment), sep='\t')
modules = enrichment_df[enrichment_df['fdr'] < 0.001]
When specifying species, use NCBI taxon IDs:
| Organism | Common Name | Taxon ID |
|---|---|---|
| Homo sapiens | Human | 9606 |
| Mus musculus | Mouse | 10090 |
| Rattus norvegicus | Rat | 10116 |
| Drosophila melanogaster | Fruit fly | 7227 |
| Caenorhabditis elegans | C. elegans | 6239 |
| Saccharomyces cerevisiae | Yeast | 4932 |
| Arabidopsis thaliana | Thale cress | 3702 |
| Escherichia coli | E. coli | 511145 |
| Danio rerio | Zebrafish | 7955 |
Full list available at: https://string-db.org/cgi/input?input_page_active_form=organisms
STRING provides combined confidence scores (0-1000) integrating multiple evidence types:
Choose threshold based on analysis goals:
Trade-offs:
Includes all evidence types (experimental, computational, text-mining). Represents proteins that are functionally associated, even without direct physical binding.
When to use:
Only includes evidence for direct physical binding (experimental data and database annotations for physical interactions).
When to use:
string_map_ids() before other operations for faster queries9606.ENSP00000269305 instead of gene namesFor comprehensive API documentation, complete parameter lists, output formats, and advanced usage, refer to references/string_reference.md. This includes:
No proteins found:
string_map_ids()Empty network results:
required_score)Timeout or slow queries:
"Species required" error:
species parameter for networks with >10 proteinsResults look unexpected:
string_version()For proteome-scale analysis or complete species network upload:
For bulk downloads of complete datasets:
STRING data is freely available under Creative Commons BY 4.0 license:
When using STRING in publications, cite the most recent publication from: https://string-db.org/cgi/about
Use when you need to run Flow type checking, or when seeing Flow type errors in React code.
Use when you want to validate changes before committing, or when you need to check all React contribution requirements.
Use when feature flag tests fail, flags need updating, understanding @gate pragmas, debugging channel-specific test failures, or adding new flags to React.
Use when you need to check feature flag states, compare channels, or debug why a feature behaves differently across release channels.