6  BLAST en local (terminal)

En este módulo aprenderemos a ejecutar BLAST de forma local desde la terminal. Utilizar BLAST local es útil cuando se trabaja con bases de datos personalizadas, grandes volúmenes de secuencias o cuando se requiere automatizar búsquedas en scripts. Cubriremos cómo crear bases de datos locales, ejecutar distintos tipos de búsquedas BLAST y recuperar las secuencias obtenidas para análisis posteriores.

6.1 Creación de bases de datos locales

Para poder buscar de forma local, primero debemos convertir nuestros archivos FASTA en bases de datos con makeblastdb, parte del paquete NCBI BLAST+. A continuación se muestran ejemplos de cómo crear:

Tipo de base de datos Comando Descripción
Proteína makeblastdb -in <archivo_proteínas>.fa -dbtype prot -out <nombre_db> Crea una base de datos de secuencias de proteína.
Núcleo (CDS/ADN) makeblastdb -in <archivo_nucleótidos>.fa -dbtype nucl -out <nombre_db> Crea una base de datos de secuencias de nucleótidos (genes, CDS, genomas).

A modo de ejemplo, supongamos que tenemos dos archivos FASTA de Trichoderma atroviride:

  • Tatroviride_proteins.fa (proteínas predichas)
  • Tatroviride_cds.fa (secuencias codificantes)

Los comandos serían:

# 1. Crear base de datos de proteínas
makeblastdb -in Tatroviride_proteins.fa -dbtype prot -out tatro_protein \
    -title "Tatroviride Proteínas" \
    -hash_index

# 2. Crear base de datos de nucleótidos (CDS)
makeblastdb -in Tatroviride_cds.fa -dbtype nucl -out tatro_cds \
    -title "Tatroviride CDS" \
    -parse_seqids

Parámetros clave de makeblastdb:

  • -in: ruta al archivo FASTA con las secuencias.
  • -dbtype: tipo de secuencia, prot para proteínas o nucl para nucleótidos.
  • -out: prefijo del nombre de la base de datos que se generará.
  • -title: (opcional) nombre descriptivo de la base de datos.
  • -hash_index: acelera búsquedas en bases de datos de proteínas grandes.
  • -parse_seqids: necesario si deseamos extraer secuencias por identificador (recomendado).

6.2 Ejecución de búsquedas BLAST

Una vez creadas las bases de datos locales, podemos usar los distintos programas BLAST para realizar comparaciones. A continuación se muestran ejemplos de búsquedas contra las bases de datos de T. atroviride.

Programa BLAST Descripción Ejemplo de comando
blastp Busca tu proteína de interés contra una base de datos de proteínas. blastp -query P06780.fasta -db tatro_protein -outfmt 6 -out blastp_Tatro.out -num_alignments 5
tblastn Busca tu proteína contra una base de datos de nucleótidos traducidos. tblastn -query P06780.fasta -db tatro_cds -outfmt 6 -out tblastn_Tatro.out -num_alignments 5
blastn Compara una secuencia de ADN contra una base de datos de ADN (nucl). blastn -query secuencia_nuc.fa -db tatro_cds -outfmt 6 -out blastn_Tatro.out -perc_identity 90 -max_hsps 1
blastx Traduce tu secuencia de ADN en seis cuadros y busca contra proteínas. blastx -query secuencia_nuc.fa -db tatro_protein -outfmt 6 -out blastx_Tatro.out -evalue 1e-5 -max_target_seqs 10
tblastx Traduce ambas secuencias (consulta y BD) y realiza la búsqueda de proteínas. tblastx -query secuencia_nuc.fa -db tatro_cds -outfmt 6 -out tblastx_Tatro.out -evalue 1e-10 -num_threads 4

6.2.1 Explicación de parámetros comunes

  • -query <archivo>.fasta: Archivo FASTA con la secuencia de consulta.
  • -db <nombre_db>: Prefijo de la base de datos generada con makeblastdb.
  • -outfmt 6: Formato de salida tabular (campos: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, e-value, bit score). Ideal para procesamiento con scripts.
  • -out <salida>.out: Nombre del archivo donde se guardará el resultado.
  • -num_alignments o -max_target_seqs: Número máximo de alineamientos a reportar (5, 10, 100, etc.).
  • -evalue <valor>: Umbral de valor E para definir cuán significativas deben ser las coincidencias.
  • -perc_identity <valor>: Porcentaje mínimo de identidad para filtrar hits (solo en algunos programas como blastn).
  • -num_threads <n>: Número de hilos a emplear para acelerar la búsqueda (útil en servidores o multicore).

6.3 Recuperacion de secuencias hits

Por lo general, después de obtener los archivos de salida en formato tabular (-outfmt 6), querrás recuperar las secuencias originales (o extendidas) de los hits para hacer análisis posteriores (alineamientos múltiples, modelado, anotaciones, etc.). Para ello, utilizaremos la herramienta SeqKit:

# 1. Extraer los IDs de la columna 2 (subject id) del archivo blastp_Tatro.out
cut -f2 blastp_Tatro.out > hits_blastp_ids.txt

# 2. Recuperar las secuencias de proteínas correspondientes
seqkit grep -f hits_blastp_ids.txt Tatroviride_proteins.fa > blastp_Tatro_hits.fasta

# 3. Para tblastn, extraer IDs de CDS (columna 2) y recuperar secuencias de nucleótidos
cut -f2 tblastn_Tatro.out > hits_tblastn_ids.txt
seqkit grep -f hits_tblastn_ids.txt Tatroviride_cds.fa > tblastn_Tatro_hits.fasta

Pasos detallados:

  1. Con cut -f2 <archivo.out> extraemos la segunda columna de la salida tabular, que corresponde al identificador de la secuencia objetivo (subject id).
  2. Con seqkit grep -f <lista_ids> <archivo_original.fa> buscamos en el FASTA original las entradas cuyo identificador coincida con los solicitados.
  3. Redirigimos la salida a un nuevo archivo FASTA que contendrá únicamente las secuencias obtenidas.

6.4 Ejemplos de formatos y campos de salida

Cuando usas -outfmt 6, obtienes un archivo de texto con once (u doce) columnas, sin encabezados. Suelen aparecer así:

query1    subjectA    98.5    350  2  0  1  350  10  359  1e-120  450
query1    subjectB    90.0    300  30 2  5  304  15  314  2e-80   320
...

Descripción de cada campo (por defecto en -outfmt 6):

  1. Query ID
  2. Subject ID
  3. % Identity
  4. Longitud del alineamiento (alignment length)
  5. Número de mismatches
  6. Aperturas de gap (gap opens)
  7. Inicio en la consulta (qstart)
  8. Fin en la consulta (qend)
  9. Inicio en el sujeto (sstart)
  10. Fin en el sujeto (send)
  11. Valor E (E-value)
  12. Puntuación en bits (bit score)

6.5 Recomendaciones y buenas prácticas

  1. Versionado y entornos reproducibles:

    • Anota la versión de BLAST+ que utilizas (blastp -version).
    • Si trabajas en distintos equipos, instala BLAST+ mediante Conda o Docker para garantizar consistencia.

  2. Tamaño de la base de datos y uso de recursos:

    • Bases de datos muy grandes pueden requerir más memoria RAM. Verifica que dispones de suficiente espacio en disco (los índices pueden ocupar varias decenas de GB).
    • Utiliza -num_threads para acelerar búsquedas en multicore, pero mantén un número razonable para no saturar la máquina.

  3. Automatización de tareas repetitivas:

    • Para múltiples consultas, crea un script en bash o Python que recorra un directorio con archivos FASTA de consulta.
    • Dentro del script, ejecuta BLAST, extrae IDs y recupera secuencias de forma automática.

Ejemplo de script básico en bash (run_all_blast.sh):

#!/usr/bin/env bash

# Directorios
QUERY_DIR="queries/"
DB_PROT="blast_db/tatro_protein"
DB_CDS="blast_db/tatro_cds"
OUT_DIR="blast_results/"

mkdir -p "${OUT_DIR}/blastp" "${OUT_DIR}/tblastn" "${OUT_DIR}/ids_blastp" "${OUT_DIR}/ids_tblastn" "${OUT_DIR}/hits_blastp" "${OUT_DIR}/hits_tblastn"

for qfile in "${QUERY_DIR}"*.fasta; do
    base=$(basename "${qfile}" .fasta)

    # blastp
    blastp -query "${qfile}" -db "${DB_PROT}" -outfmt 6 -max_target_seqs 5 \
        -num_threads 4 -out "${OUT_DIR}/blastp/${base}_blastp.out"
    cut -f2 "${OUT_DIR}/blastp/${base}_blastp.out" > "${OUT_DIR}/ids_blastp/${base}_ids.txt"
    seqkit grep -f "${OUT_DIR}/ids_blastp/${base}_ids.txt" Tatroviride_proteins.fa > "${OUT_DIR}/hits_blastp/${base}_hits.fasta"

    # tblastn
    tblastn -query "${qfile}" -db "${DB_CDS}" -outfmt 6 -max_target_seqs 5 \
        -num_threads 4 -out "${OUT_DIR}/tblastn/${base}_tblastn.out"
    cut -f2 "${OUT_DIR}/tblastn/${base}_tblastn.out" > "${OUT_DIR}/ids_tblastn/${base}_ids.txt"
    seqkit grep -f "${OUT_DIR}/ids_tblastn/${base}_ids.txt" Tatroviride_cds.fa > "${OUT_DIR}/hits_tblastn/${base}_hits.fasta"
done

  1. Documentación y metadatos:

    • Mantén un archivo README.md en tu proyecto donde describas cada paso: cómo crear las bases de datos, qué parámetros usaste en BLAST, versiones de herramientas y organización de carpetas.
    • Esto facilitará la colaboración y reproducibilidad a largo plazo.

  2. Interpretación de resultados y filtrado post-BLAST:

    • Después de recuperar las secuencias, realiza alineamientos múltiples (con MAFFT o Clustal Omega) para verificar la calidad de las coincidencias.
    • Aplica filtros según valor E, % de identidad y cobertura para quedarte con hits de alta confianza antes de análisis posteriores (como árboles filogenéticos o modelado estructural).