// Access BRENDA enzyme database via SOAP API. Retrieve kinetic parameters (Km, kcat), reaction equations, organism data, and substrate-specific enzyme information for biochemical research and metabolic pathway analysis.
| name | brenda_database |
| description | Access BRENDA enzyme database via SOAP API. Retrieve kinetic parameters (Km, kcat), reaction equations, organism data, and substrate-specific enzyme information for biochemical research and metabolic pathway analysis. |
| license | Unknown |
| metadata | {"skill-author":"VenusFactory2."} |
BRENDA (BRaunschweig ENzyme DAtabase) is the world's most comprehensive enzyme information system, containing detailed enzyme data from scientific literature. In this project the agent exposes only download tools: save Km values, reactions, enzyme-by-substrate results, organism comparison, environmental parameters, kinetic data export, and pathway reports to files; each returns JSON {success, file_path[, error]}. For programmatic use, the package also provides query-style APIs (see Project Modules). Access over 45,000 enzymes with millions of kinetic data points for biochemical research, metabolic engineering, and enzyme discovery.
This skill should be used when:
The skill provides:
src/tools/search/tools_agent.py: the agent exposes only download operations; each returns JSON {success, file_path[, error]}. See table below.src/tools/database/brenda/: brenda_client.py (SOAP), brenda_queries.py, enzyme_pathway_builder.py, brenda_operations.py; all re-exported via package. For programmatic use (including query-style APIs), import e.g. from src.tools.database.brenda import download_brenda_km_values_by_ec_number, query_brenda_km_values_by_ec_number, ....references/api_reference.md| Tool name | Arguments | Purpose |
|---|---|---|
download_brenda_km_values_by_ec_number | ec_number, out_path, organism (optional), substrate (optional) | Download Km values by EC number to .json or .txt |
download_brenda_reactions_by_ec_number | ec_number, out_path, organism (optional) | Download reaction equations by EC number to file |
download_brenda_enzymes_by_substrate | substrate, out_path, limit (optional) | Download enzyme-by-substrate search results to JSON |
download_brenda_compare_organisms_by_ec_number | ec_number, organisms, out_path | Download organism comparison by EC number to JSON |
download_brenda_environmental_parameters_by_ec_number | ec_number, out_path | Download environmental parameters (pH, temperature) by EC number to JSON |
download_brenda_kinetic_data_by_ec_number | ec_number, out_path, format (optional: json/csv) | Download kinetic data export by EC number to file |
download_brenda_pathway_report | pathway (dict), out_path | Generate and save pathway report from pathway data to file |
All require BRENDA_EMAIL and BRENDA_PASSWORD in the environment.
| Capability | Function | Module | Purpose |
|---|---|---|---|
| SOAP Km | get_km_values(ec_number, organism=*, substrate=*) | brenda_client.py | Raw Km entries from BRENDA |
| SOAP reactions | get_reactions(ec_number, organism=*, reaction=*) | brenda_client.py | Raw reaction entries |
| Parse Km | parse_km_entry(entry) | brenda_queries.py | Parse Km string to dict |
| Parse reaction | parse_reaction_entry(entry), extract_substrate_products(entry) | brenda_queries.py | Parse reaction / get substrates & products |
| Organism data | extract_organism_data(entry) | brenda_queries.py | Extract organism info from entry |
| Search by substrate | search_enzymes_by_substrate(substrate, limit) | brenda_queries.py | Find enzymes for substrate |
| Search by product | search_enzymes_by_product(product, limit) | brenda_queries.py | Find enzymes producing product |
| Search by pattern | search_by_pattern(pattern, limit) | brenda_queries.py | Find enzymes by reaction pattern |
| Compare organisms | compare_across_organisms(ec_number, organisms) | brenda_queries.py | Compare enzyme data across organisms |
| Organisms for enzyme | get_organisms_for_enzyme(ec_number) | brenda_queries.py | List organisms with enzyme |
| Environmental params | get_environmental_parameters(ec_number) | brenda_queries.py | pH, temperature, stability |
| Cofactors | get_cofactor_requirements(ec_number) | brenda_queries.py | Cofactor requirements |
| Substrate specificity | get_substrate_specificity(ec_number), compare_substrate_affinity(ec_number) | brenda_queries.py | Substrate affinity data |
| Inhibitors / activators | get_inhibitors(ec_number), get_activators(ec_number) | brenda_queries.py | Inhibition / activation |
| Thermophilic / pH variants | find_thermophilic_homologs(ec_number, min_temp), find_ph_stable_variants(...) | brenda_queries.py | Engineering variants |
| Modeling params | get_modeling_parameters(ec_number, substrate) | brenda_queries.py | Km, kcat, Vmax for modeling |
| Export data | export_kinetic_data(ec_number, format, filename) | brenda_queries.py | Export to CSV/JSON/Excel |
| Pathway | find_pathway_for_product(product, max_steps), build_retrosynthetic_tree(target, depth) | enzyme_pathway_builder.py | Pathway and retrosynthesis |
| Pathway utils | suggest_enzyme_substitutions, calculate_pathway_feasibility, optimize_pathway_conditions, generate_pathway_report | enzyme_pathway_builder.py | Pathway analysis and report |
Access comprehensive kinetic data for enzymes:
Get Km Values by EC Number:
from src.tools.database.brenda import get_km_values
# Get Km values for all organisms
km_data = get_km_values("1.1.1.1") # Alcohol dehydrogenase
# Get Km values for specific organism
km_data = get_km_values("1.1.1.1", organism="Saccharomyces cerevisiae")
# Get Km values for specific substrate
km_data = get_km_values("1.1.1.1", substrate="ethanol")
Parse Km Results:
for entry in km_data:
print(f"Km: {entry}")
# Example output: "organism*Homo sapiens#substrate*ethanol#kmValue*1.2#commentary*"
Extract Specific Information:
from src.tools.database.brenda import parse_km_entry, extract_organism_data
for entry in km_data:
parsed = parse_km_entry(entry)
organism = extract_organism_data(entry)
print(f"Organism: {parsed['organism']}")
print(f"Substrate: {parsed['substrate']}")
print(f"Km value: {parsed['km_value']}")
print(f"pH: {parsed.get('ph', 'N/A')}")
print(f"Temperature: {parsed.get('temperature', 'N/A')}")
Retrieve reaction equations and details:
Get Reactions by EC Number:
from src.tools.database.brenda import get_reactions
# Get all reactions for EC number
reactions = get_reactions("1.1.1.1")
# Filter by organism
reactions = get_reactions("1.1.1.1", organism="Escherichia coli")
# Search specific reaction
reactions = get_reactions("1.1.1.1", reaction="ethanol + NAD+")
Process Reaction Data:
from src.tools.database.brenda import parse_reaction_entry, extract_substrate_products
for reaction in reactions:
parsed = parse_reaction_entry(reaction)
substrates, products = extract_substrate_products(reaction)
print(f"Reaction: {parsed['reaction']}")
print(f"Organism: {parsed['organism']}")
print(f"Substrates: {substrates}")
print(f"Products: {products}")
Find enzymes for specific biochemical transformations:
Find Enzymes by Substrate:
from src.tools.database.brenda import search_enzymes_by_substrate
# Find enzymes that act on glucose
enzymes = search_enzymes_by_substrate("glucose", limit=20)
for enzyme in enzymes:
print(f"EC: {enzyme['ec_number']}")
print(f"Name: {enzyme['enzyme_name']}")
print(f"Reaction: {enzyme['reaction']}")
Find Enzymes by Product:
from src.tools.database.brenda import search_enzymes_by_product
# Find enzymes that produce lactate
enzymes = search_enzymes_by_product("lactate", limit=10)
Search by Reaction Pattern:
from src.tools.database.brenda import search_by_pattern
# Find oxidation reactions
enzymes = search_by_pattern("oxidation", limit=15)
Compare enzyme properties across organisms:
Get Enzyme Data for Multiple Organisms:
from src.tools.database.brenda import compare_across_organisms
organisms = ["Escherichia coli", "Saccharomyces cerevisiae", "Homo sapiens"]
comparison = compare_across_organisms("1.1.1.1", organisms)
for org_data in comparison:
print(f"Organism: {org_data['organism']}")
print(f"Avg Km: {org_data['average_km']}")
print(f"Optimal pH: {org_data['optimal_ph']}")
print(f"Temperature range: {org_data['temperature_range']}")
Find Organisms with Specific Enzyme:
from src.tools.database.brenda import get_organisms_for_enzyme
organisms = get_organisms_for_enzyme("6.3.5.5") # Glutamine synthetase
print(f"Found {len(organisms)} organisms with this enzyme")
Access optimal conditions and environmental parameters:
Get pH and Temperature Data:
from src.tools.database.brenda import get_environmental_parameters
params = get_environmental_parameters("1.1.1.1")
print(f"Optimal pH range: {params['ph_range']}")
print(f"Optimal temperature: {params['optimal_temperature']}")
print(f"Stability pH: {params['stability_ph']}")
print(f"Temperature stability: {params['temperature_stability']}")
Cofactor Requirements:
from src.tools.database.brenda import get_cofactor_requirements
cofactors = get_cofactor_requirements("1.1.1.1")
for cofactor in cofactors:
print(f"Cofactor: {cofactor['name']}")
print(f"Type: {cofactor['type']}")
print(f"Concentration: {cofactor['concentration']}")
Analyze enzyme substrate preferences:
Get Substrate Specificity Data:
from src.tools.database.brenda import get_substrate_specificity
specificity = get_substrate_specificity("1.1.1.1")
for substrate in specificity:
print(f"Substrate: {substrate['name']}")
print(f"Km: {substrate['km']}")
print(f"Vmax: {substrate['vmax']}")
print(f"kcat: {substrate['kcat']}")
print(f"Specificity constant: {substrate['kcat_km_ratio']}")
Compare Substrate Preferences:
from src.tools.database.brenda import compare_substrate_affinity
comparison = compare_substrate_affinity("1.1.1.1")
sorted_by_km = sorted(comparison, key=lambda x: x['km'])
for substrate in sorted_by_km[:5]: # Top 5 lowest Km
print(f"{substrate['name']}: Km = {substrate['km']}")
Access enzyme regulation data:
Get Inhibitor Information:
from src.tools.database.brenda import get_inhibitors
inhibitors = get_inhibitors("1.1.1.1")
for inhibitor in inhibitors:
print(f"Inhibitor: {inhibitor['name']}")
print(f"Type: {inhibitor['type']}")
print(f"Ki: {inhibitor['ki']}")
print(f"IC50: {inhibitor['ic50']}")
Get Activator Information:
from src.tools.database.brenda import get_activators
activators = get_activators("1.1.1.1")
for activator in activators:
print(f"Activator: {activator['name']}")
print(f"Effect: {activator['effect']}")
print(f"Mechanism: {activator['mechanism']}")
Find engineering targets and alternatives:
Find Thermophilic Homologs:
from src.tools.database.brenda import find_thermophilic_homologs
thermophilic = find_thermophilic_homologs("1.1.1.1", min_temp=50)
for enzyme in thermophilic:
print(f"Organism: {enzyme['organism']}")
print(f"Optimal temp: {enzyme['optimal_temperature']}")
print(f"Km: {enzyme['km']}")
Find Alkaline/ Acid Stable Variants:
from src.tools.database.brenda import find_ph_stable_variants
alkaline = find_ph_stable_variants("1.1.1.1", min_ph=8.0)
acidic = find_ph_stable_variants("1.1.1.1", max_ph=6.0)
Prepare data for kinetic modeling:
Get Kinetic Parameters for Modeling:
from src.tools.database.brenda import get_modeling_parameters
model_data = get_modeling_parameters("1.1.1.1", substrate="ethanol")
print(f"Km: {model_data['km']}")
print(f"Vmax: {model_data['vmax']}")
print(f"kcat: {model_data['kcat']}")
print(f"Enzyme concentration: {model_data['enzyme_conc']}")
print(f"Temperature: {model_data['temperature']}")
print(f"pH: {model_data['ph']}")
uv pip install zeep requests pandas
BRENDA requires authentication credentials:
BRENDA_EMAIL=your.email@example.com
BRENDA_PASSWORD=your_brenda_password
export BRENDA_EMAIL="your.email@example.com"
export BRENDA_PASSWORD="your_brenda_password"
BRENDA_EMIAL (note the typo) for legacy supportScripts live in src/tools/database/brenda/. Import from package: from src.tools.database.brenda import ...
Provides high-level functions for enzyme data analysis:
Key Functions:
parse_km_entry(entry): Parse BRENDA Km data entriesparse_reaction_entry(entry): Parse reaction data entriesextract_substrate_products(entry): Return (substrates, products) from reaction entryextract_organism_data(entry): Extract organism-specific informationsearch_enzymes_by_substrate(substrate, limit): Find enzymes for substratessearch_enzymes_by_product(product, limit): Find enzymes producing productscompare_across_organisms(ec_number, organisms): Compare enzyme propertiesget_environmental_parameters(ec_number): Get pH and temperature dataget_cofactor_requirements(ec_number): Get cofactor informationget_substrate_specificity(ec_number): Analyze substrate preferencesget_inhibitors(ec_number): Get enzyme inhibition dataget_activators(ec_number): Get enzyme activation datafind_thermophilic_homologs(ec_number, min_temp): Find heat-stable variantsget_modeling_parameters(ec_number, substrate): Get parameters for kinetic modelingexport_kinetic_data(ec_number, format, filename): Export data to fileUsage:
from src.tools.database.brenda import search_enzymes_by_substrate, compare_across_organisms
# Search for enzymes
enzymes = search_enzymes_by_substrate("glucose", limit=20)
# Compare across organisms
comparison = compare_across_organisms("1.1.1.1", ["E. coli", "S. cerevisiae"])
Build enzymatic pathways and retrosynthetic routes:
Key Functions:
find_pathway_for_product(product, max_steps): Find enzymatic pathwaysbuild_retrosynthetic_tree(target, depth): Build retrosynthetic treesuggest_enzyme_substitutions(ec_number, criteria): Suggest enzyme alternativescalculate_pathway_feasibility(pathway): Evaluate pathway viabilityoptimize_pathway_conditions(pathway): Suggest optimal conditionsgenerate_pathway_report(pathway, filename): Create detailed pathway reportUsage:
from src.tools.database.brenda import find_pathway_for_product, build_retrosynthetic_tree
# Find pathway to product
pathway = find_pathway_for_product("lactate", max_steps=3)
# Build retrosynthetic tree
tree = build_retrosynthetic_tree("lactate", depth=2)
Rate Limits:
Best Practices:
Error Handling:
from src.tools.database.brenda import get_km_values, get_reactions
from zeep.exceptions import Fault, TransportError # if using zeep directly
try:
km_data = get_km_values("1.1.1.1")
except RuntimeError as e:
print(f"Authentication error: {e}")
except Fault as e:
print(f"BRENDA API error: {e}")
except TransportError as e:
print(f"Network error: {e}")
except Exception as e:
print(f"Unexpected error: {e}")
Find suitable enzymes for a specific substrate:
from src.tools.database.brenda import get_km_values
from src.tools.database.brenda import search_enzymes_by_substrate, compare_substrate_affinity
# Search for enzymes that act on substrate
substrate = "2-phenylethanol"
enzymes = search_enzymes_by_substrate(substrate, limit=15)
print(f"Found {len(enzymes)} enzymes for {substrate}")
for enzyme in enzymes:
print(f"EC {enzyme['ec_number']}: {enzyme['enzyme_name']}")
# Get kinetic data for best candidates
if enzymes:
best_ec = enzymes[0]['ec_number']
km_data = get_km_values(best_ec, substrate=substrate)
if km_data:
print(f"Kinetic data for {best_ec}:")
for entry in km_data[:3]: # First 3 entries
print(f" {entry}")
Compare enzyme properties across different organisms:
from src.tools.database.brenda import compare_across_organisms, get_environmental_parameters
# Define organisms for comparison
organisms = [
"Escherichia coli",
"Saccharomyces cerevisiae",
"Bacillus subtilis",
"Thermus thermophilus"
]
# Compare alcohol dehydrogenase
comparison = compare_across_organisms("1.1.1.1", organisms)
print("Cross-organism comparison:")
for org_data in comparison:
print(f"\n{org_data['organism']}:")
print(f" Average Km: {org_data['average_km']}")
print(f" Optimal pH: {org_data['optimal_ph']}")
print(f" Temperature: {org_data['optimal_temperature']}°C")
# Get detailed environmental parameters
env_params = get_environmental_parameters("1.1.1.1")
print(f"\nOverall optimal pH range: {env_params['ph_range']}")
Find engineering opportunities for enzyme improvement:
from src.tools.database.brenda import (
find_thermophilic_homologs,
find_ph_stable_variants,
compare_substrate_affinity
)
# Find thermophilic variants for heat stability
thermophilic = find_thermophilic_homologs("1.1.1.1", min_temp=50)
print(f"Found {len(thermophilic)} thermophilic variants")
# Find alkaline-stable variants
alkaline = find_ph_stable_variants("1.1.1.1", min_ph=8.0)
print(f"Found {len(alkaline)} alkaline-stable variants")
# Compare substrate specificities for engineering targets
specificity = compare_substrate_affinity("1.1.1.1")
print("Substrate affinity ranking:")
for i, sub in enumerate(specificity[:5]):
print(f" {i+1}. {sub['name']}: Km = {sub['km']}")
Build enzymatic synthesis pathways:
from src.tools.database.brenda import (
find_pathway_for_product,
build_retrosynthetic_tree,
calculate_pathway_feasibility
)
# Find pathway to target product
target = "lactate"
pathway = find_pathway_for_product(target, max_steps=3)
if pathway:
print(f"Found pathway to {target}:")
for i, step in enumerate(pathway['steps']):
print(f" Step {i+1}: {step['reaction']}")
print(f" Enzyme: EC {step['ec_number']}")
print(f" Organism: {step['organism']}")
# Evaluate pathway feasibility
feasibility = calculate_pathway_feasibility(pathway)
print(f"\nPathway feasibility score: {feasibility['score']}/10")
print(f"Potential issues: {feasibility['warnings']}")
Comprehensive kinetic analysis for enzyme selection:
from src.tools.database.brenda import get_km_values
from src.tools.database.brenda.brenda_queries import parse_km_entry, get_modeling_parameters
# Get comprehensive kinetic data
ec_number = "1.1.1.1"
km_data = get_km_values(ec_number)
# Analyze kinetic parameters
all_entries = []
for entry in km_data:
parsed = parse_km_entry(entry)
if parsed['km_value']:
all_entries.append(parsed)
print(f"Analyzed {len(all_entries)} kinetic entries")
# Find best kinetic performer
best_km = min(all_entries, key=lambda x: x['km_value'])
print(f"\nBest kinetic performer:")
print(f" Organism: {best_km['organism']}")
print(f" Substrate: {best_km['substrate']}")
print(f" Km: {best_km['km_value']}")
# Get modeling parameters
model_data = get_modeling_parameters(ec_number, substrate=best_km['substrate'])
print(f"\nModeling parameters:")
print(f" Km: {model_data['km']}")
print(f" kcat: {model_data['kcat']}")
print(f" Vmax: {model_data['vmax']}")
Select enzymes for industrial applications:
from src.tools.database.brenda import (
find_thermophilic_homologs,
get_environmental_parameters,
get_inhibitors
)
# Industrial criteria: high temperature tolerance, organic solvent resistance
target_enzyme = "1.1.1.1"
# Find thermophilic variants
thermophilic = find_thermophilic_homologs(target_enzyme, min_temp=60)
print(f"Thermophilic candidates: {len(thermophilic)}")
# Check solvent tolerance (inhibitor data)
inhibitors = get_inhibitors(target_enzyme)
solvent_tolerant = [
inv for inv in inhibitors
if 'ethanol' not in inv['name'].lower() and
'methanol' not in inv['name'].lower()
]
print(f"Solvent tolerant candidates: {len(solvent_tolerant)}")
# Evaluate top candidates
for candidate in thermophilic[:3]:
print(f"\nCandidate: {candidate['organism']}")
print(f" Optimal temp: {candidate['optimal_temperature']}°C")
print(f" Km: {candidate['km']}")
print(f" pH range: {candidate.get('ph_range', 'N/A')}")
BRENDA returns data in specific formats that need parsing:
Km Value Format:
organism*Escherichia coli#substrate*ethanol#kmValue*1.2#kmValueMaximum*#commentary*pH 7.4, 25°C#ligandStructureId*#literature*
Reaction Format:
ecNumber*1.1.1.1#organism*Saccharomyces cerevisiae#reaction*ethanol + NAD+ <=> acetaldehyde + NADH + H+#commentary*#literature*
import re
def parse_brenda_field(data, field_name):
"""Extract specific field from BRENDA data entry"""
pattern = f"{field_name}\\*([^#]*)"
match = re.search(pattern, data)
return match.group(1) if match else None
def extract_multiple_values(data, field_name):
"""Extract multiple values for a field"""
pattern = f"{field_name}\\*([^#]*)"
matches = re.findall(pattern, data)
return [match for match in matches if match.strip()]
For detailed BRENDA documentation, see references/api_reference.md. This includes:
Authentication Errors:
No Results Returned:
Rate Limiting:
Network Errors:
Data Format Issues:
Performance Issues:
Access AlphaFold 200M+ AI-predicted protein structures. Retrieve structures by UniProt ID, download PDB/mmCIF files, analyze confidence metrics (pLDDT, PAE), for drug discovery and structural biology.
Comprehensive molecular biology toolkit. Use for sequence manipulation, file parsing (FASTA/GenBank/PDB), phylogenetics, and programmatic NCBI/PubMed access (Bio.Entrez). Best for batch processing, custom bioinformatics pipelines, BLAST automation.
Query ChEMBL bioactive molecules and drug discovery data. Search compounds by structure/properties, retrieve bioactivity data (IC50, Ki), find inhibitors, perform SAR studies, for medicinal chemistry.
Query openFDA API for drugs, devices, adverse events, recalls, regulatory submissions (510k, PMA), substance identification (UNII), for FDA regulatory data analysis and safety research.
Direct REST API access to KEGG (academic use only). Pathway analysis, gene-pathway mapping, metabolic pathways, drug interactions, ID conversion. Use this for direct HTTP/REST work or KEGG-specific control.
Low-level plotting library for full customization. Use when you need fine-grained control over every plot element, creating novel plot types, or integrating with specific scientific workflows. Export to PNG/PDF/SVG for publication. For quick statistical plots use seaborn; for interactive plots use plotly; for publication-ready multi-panel figures with journal styling, use scientific-visualization.