jueves, 3 de julio de 2025

Análisis de MySQL: Con una Herramienta CLI Potenciada por IA

Análisis de MySQL: Con una Herramienta CLI Potenciada por IA

Como DBAs con MySQL, a menudo vivimos en una ventana de terminal de Linux. También disfrutamos de opciones gratuitas cuando están disponibles. Este post muestra un enfoque que nos permite permanecer en nuestra ventana de terminal y aún así usar una herramienta potenciada por IA. Puedes actualizarlo para usar otros proveedores directos de IA, pero configuré este ejemplo para usar aimlapi.com ya que trae múltiples modelos de IA a tu terminal de forma gratuita con uso limitado o costo muy bajo para más pruebas.

Nota: No soy un portavoz pagado de AIMLAPI ni nada por el estilo - esto es solo un ejemplo sencillo para destacar la idea.

El Problema

Estás viendo una base de datos heredada con cientos de tablas, cada una con relaciones complejas y decisiones de diseño cuestionables tomadas hace años. El proceso usual involucra:

  • Inspección manual del esquema
  • Referencias cruzadas de documentación (si existe)
  • Ejecutar múltiples consultas EXPLAIN
  • Consultar guías de mejores prácticas
  • Buscar segundas opiniones de colegas

Esto toma tiempo y a menudo se pasan cosas por alto.

Un Enfoque Basado en CLI

Podemos aprovechar la IA directamente desde nuestro CLI y hacer numerosas cosas. Ayudar con el análisis de MySQL es solo un ejemplo de cómo este enfoque puede funcionar con nuestras tareas diarias de base de datos. Al combinar las capacidades nativas de MySQL con modelos de IA, todo accesible a través de una interfaz de línea de comandos simple, podemos obtener insights sin salir de nuestro terminal. AIMLAPI proporciona acceso gratuito a más de 100 modelos de IA con uso limitado, haciendo este enfoque accesible. Para pruebas más intensivas, los costos siguen siendo muy razonables.

La Herramienta: AIMLAPI CLI

Así que aquí hay un script bash que proporciona acceso a más de 100 modelos de IA a través de una sola interfaz:

#!/bin/bash
# Herramienta CLI AIMLAPI con acceso a más de 100 modelos de IA
# Archivo: ~/.local/bin/aiml

# Configuración
DEFAULT_MODEL=${AIMLAPI_DEFAULT_MODEL:-"gpt-4o"}
MAX_TOKENS=${AIMLAPI_MAX_TOKENS:-2000}
TEMPERATURE=${AIMLAPI_TEMPERATURE:-0.7}
BASE_URL="https://api.aimlapi.com"
ENDPOINT="v1/chat/completions"

# Códigos de color para salida
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # Sin Color

# Función para imprimir salida coloreada
print_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
print_success() { echo -e "${GREEN}[ÉXITO]${NC} $1"; }
print_warning() { echo -e "${YELLOW}[ADVERTENCIA]${NC} $1"; }
print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
print_model() { echo -e "${PURPLE}[MODELO]${NC} $1"; }

# Atajos de modelos populares
declare -A MODEL_SHORTCUTS=(
    # Modelos OpenAI
    ["gpt4"]="gpt-4o"
    ["gpt4o"]="gpt-4o"
    ["gpt4mini"]="gpt-4o-mini"
    ["o1"]="o1-preview"
    ["o3"]="openai/o3-2025-04-16"
    
    # Modelos Claude  
    ["claude"]="claude-3-5-sonnet-20241022"
    ["claude4"]="anthropic/claude-sonnet-4"
    ["opus"]="claude-3-opus-20240229"
    ["haiku"]="claude-3-5-haiku-20241022"
    ["sonnet"]="claude-3-5-sonnet-20241022"
    
    # Modelos DeepSeek
    ["deepseek"]="deepseek-chat"
    ["deepseek-r1"]="deepseek/deepseek-r1"
    ["reasoner"]="deepseek-reasoner"
    
    # Modelos Google
    ["gemini"]="gemini-2.0-flash"
    ["gemini2"]="gemini-2.0-flash"
    ["gemini15"]="gemini-1.5-pro"
    
    # Modelos Meta Llama
    ["llama"]="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"
    ["llama405b"]="meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo"
    
    # Modelos Qwen
    ["qwen"]="qwen-max"
    ["qwq"]="Qwen/QwQ-32B"
    
    # Modelos Grok
    ["grok"]="x-ai/grok-beta"
    ["grok3"]="x-ai/grok-3-beta"
    
    # Modelos Especializados
    ["coder"]="Qwen/Qwen2.5-Coder-32B-Instruct"
)

# Función para resolver atajos de modelos
resolve_model() {
    local model="$1"
    if [[ -n "${MODEL_SHORTCUTS[$model]}" ]]; then
        echo "${MODEL_SHORTCUTS[$model]}"
    else
        echo "$model"
    fi
}

# Función para crear payload JSON usando jq para escape adecuado
create_json_payload() {
    local model="$1"
    local prompt="$2"
    local system_prompt="$3"
    
    local temp_file=$(mktemp)
    echo "$prompt" > "$temp_file"
    
    if [ -n "$system_prompt" ]; then
        jq -n --arg model "$model" \
              --rawfile prompt "$temp_file" \
              --arg system "$system_prompt" \
              --argjson max_tokens "$MAX_TOKENS" \
              --argjson temperature "$TEMPERATURE" \
              '{
                model: $model,
                messages: [{role: "system", content: $system}, {role: "user", content: $prompt}],
                max_tokens: $max_tokens,
                temperature: $temperature
              }'
    else
        jq -n --arg model "$model" \
              --rawfile prompt "$temp_file" \
              --argjson max_tokens "$MAX_TOKENS" \
              --argjson temperature "$TEMPERATURE" \
              '{
                model: $model,
                messages: [{role: "user", content: $prompt}],
                max_tokens: $max_tokens,
                temperature: $temperature
              }'
    fi
    
    rm -f "$temp_file"
}

# Función para llamar a AIMLAPI
call_aimlapi() {
    local prompt="$1"
    local model="$2"
    local system_prompt="$3"
    
    if [ -z "$AIMLAPI_API_KEY" ]; then
        print_error "AIMLAPI_API_KEY no está configurada"
        return 1
    fi
    
    model=$(resolve_model "$model")
    
    local json_file=$(mktemp)
    create_json_payload "$model" "$prompt" "$system_prompt" > "$json_file"
    
    local response_file=$(mktemp)
    local http_code=$(curl -s -w "%{http_code}" -X POST "${BASE_URL}/${ENDPOINT}" \
        -H "Content-Type: application/json" \
        -H "Authorization: Bearer $AIMLAPI_API_KEY" \
        --data-binary @"$json_file" \
        -o "$response_file")
    
    if [ "$http_code" -ne 200 ] && [ "$http_code" -ne 201 ]; then
        print_error "Error HTTP $http_code"
        cat "$response_file" >&2
        rm -f "$json_file" "$response_file"
        return 1
    fi
    
    local content=$(jq -r '.choices[0].message.content // empty' "$response_file" 2>/dev/null)
    
    if [ -z "$content" ]; then
        content=$(jq -r '.choices[0].text // .message.content // .content // empty' "$response_file" 2>/dev/null)
    fi
    
    if [ -z "$content" ]; then
        local error_msg=$(jq -r '.error.message // .error // empty' "$response_file" 2>/dev/null)
        if [ -n "$error_msg" ]; then
            echo "Error de API: $error_msg"
        else
            echo "Error: No se puede analizar la respuesta de la API"
        fi
    else
        echo "$content"
    fi
    
    rm -f "$json_file" "$response_file"
}

# Función principal con análisis de argumentos
main() {
    local model="$DEFAULT_MODEL"
    local system_prompt=""
    local prompt=""
    local piped_input=""
    
    if [ -p /dev/stdin ]; then
        piped_input=$(cat)
    fi
    
    # Analizar argumentos
    while [[ $# -gt 0 ]]; do
        case $1 in
            -m|--model)
                model="$2"
                shift 2
                ;;
            -s|--system)
                system_prompt="$2"
                shift 2
                ;;
            *)
                prompt="$*"
                break
                ;;
        esac
    done
    
    # Manejar entrada
    if [ -n "$piped_input" ] && [ -n "$prompt" ]; then
        prompt="$prompt

Aquí están los datos para analizar:
$piped_input"
    elif [ -n "$piped_input" ]; then
        prompt="Por favor analiza estos datos:

$piped_input"
    elif [ -z "$prompt" ]; then
        echo "Uso: aiml [opciones] \"prompt\""
        echo "       comando | aiml [opciones]"
        exit 1
    fi
    
    local resolved_model=$(resolve_model "$model")
    print_info "Consultando $resolved_model..."
    
    local response=$(call_aimlapi "$prompt" "$model" "$system_prompt")
    
    echo ""
    print_model "Respuesta de $resolved_model:"
    echo "----------------------------------------"
    echo "$response" 
    echo "----------------------------------------"
}

# Verificar dependencias
check_dependencies() {
    command -v curl >/dev/null 2>&1 || { print_error "curl requerido pero no instalado."; exit 1; }
    command -v jq >/dev/null 2>&1 || { print_error "jq requerido pero no instalado."; exit 1; }
}

check_dependencies
main "$@"

Este script proporciona acceso a varios modelos de IA a través de atajos simples como claude4, gpt4, grok3, etc. AIMLAPI ofrece acceso gratuito con uso limitado a todos estos modelos, con costos razonables para pruebas adicionales. Bueno para DBAs que quieren experimentar sin romper el presupuesto.

Características del Script

El script incluye ayuda comprensiva. Aquí está lo que muestra aiml --help:

Herramienta CLI AIMLAPI - Acceso a más de 100 Modelos de IA
=============================================================
Uso: aiml [OPCIONES] "prompt"
     comando | aiml [OPCIONES]
Opciones Principales:
  -m, --model MODELO        Modelo a usar (predeterminado: gpt-4o)
  -t, --tokens NÚMERO       Tokens máximos (predeterminado: 2000)
  -T, --temperature FLOAT   Temperatura 0.0-2.0 (predeterminado: 0.7)
  -s, --system PROMPT       Prompt del sistema para comportamiento del modelo
Opciones de Entrada/Salida:
  -f, --file ARCHIVO        Leer prompt desde archivo
  -o, --output ARCHIVO      Guardar respuesta en archivo
  -r, --raw                 Salida cruda (sin formato/colores)
Opciones de Información:
  -l, --list               Listar atajos de modelos populares
  --get-models             Obtener todos los modelos disponibles de la API
  -c, --config             Mostrar configuración actual
  -v, --verbose            Habilitar salida detallada
  -d, --debug              Mostrar información de depuración
  -h, --help               Mostrar esta ayuda
Ejemplos Básicos:
  aiml "explica computación cuántica"
  aiml -m claude "revisa este código"
  aiml -m deepseek-r1 "resuelve este problema matemático paso a paso"
  aiml -m grok3 "¿cuáles son los últimos desarrollos en IA?"
  aiml -m coder "optimiza esta función de Python"
Ejemplos con Pipe:
  ps aux | aiml "analiza estos procesos"
  netstat -tuln | aiml "explica estas conexiones de red"
  cat error.log | aiml -m claude "diagnostica estos errores"
  git diff | aiml -m coder "revisa estos cambios de código"
  df -h | aiml "analiza el uso del disco y sugiere limpieza"
Operaciones con Archivos:
  aiml -f prompt.txt -o response.txt
  aiml -f large_dataset.csv -m llama405b "analiza estos datos"
  cat script.py | aiml -m coder -o review.md "revisión de código"
Categorías de Modelos y Atajos:
  OpenAI:     gpt4, gpt4mini, o1, o3
  Claude:     claude, opus, haiku, sonnet, claude4
  DeepSeek:   deepseek, deepseek-r1, reasoner
  Google:     gemini, gemini2, gemma
  Meta:       llama, llama3, llama4, llama405b
  Qwen:       qwen, qwen2, qwq
  Grok:       grok, grok3, grok3mini
  Codificación: coder, codestral
Uso Avanzado:
  aiml -m claude -s "Eres un experto en seguridad" "audita este código"
  aiml -m deepseek-r1 -t 3000 "tarea de razonamiento complejo"
  aiml -v -m grok3 "consulta detallada con logging detallado"
  aiml -d "modo de depuración para solucionar problemas de API"
Descubrimiento de Modelos:
  aiml -l                   # Mostrar atajos populares
  aiml --get-models         # Obtener todos los modelos disponibles de la API
  aiml --config             # Mostrar configuración actual
Variables de Entorno:
  AIMLAPI_API_KEY          - Tu clave AIMLAPI (requerida)
  AIMLAPI_DEFAULT_MODEL    - Modelo predeterminado (opcional)
  AIMLAPI_MAX_TOKENS       - Tokens máximos predeterminados (opcional)
  AIMLAPI_TEMPERATURE      - Temperatura predeterminada (opcional)
Consejos Profesionales:
  • Usa coder para tareas de programación y revisiones de código
  • Usa deepseek-r1 para razonamiento complejo y problemas matemáticos
  • Usa claude4 para análisis detallado y contenido de formato largo
  • Usa grok3 para eventos actuales e información en tiempo real
  • Usa gpt4mini para preguntas rápidas para ahorrar en costos de API
  • Envía salida de comandos directamente: comando | aiml "analiza esto"
  • Usa -v para salida detallada para ver qué modelo se está usando
  • Usa --get-models para ver todos los más de 100 modelos disponibles

¡Acceso a más de 100 modelos de IA a través de una interfaz simple!

Ejemplo: La Tabla City

Aquí está cómo esto funciona con un análisis real de tabla MySQL. Analizaré una tabla City de la clásica base de datos World (de https://dev.mysql.com/doc/index-other.html Bases de Datos de Ejemplo) usando tres modelos de IA diferentes.

El Comando

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model claude4 "Usando un punto de vista experto en MySQL analiza esta tabla"

Este comando:

  1. Extrae la estructura de la tabla desde MySQL
  2. La envía por pipe a nuestra herramienta de IA
  3. Obtiene análisis de Claude Sonnet 4

Resultados

Análisis de Claude Sonnet 4

Claude 4 proporcionó un análisis bien organizado:

Fortalezas:

  • Clave primaria AUTO_INCREMENT adecuada para eficiencia de InnoDB
  • Restricciones de clave foránea manteniendo integridad referencial
  • Estrategia de indexación apropiada para consultas comunes

Problemas Encontrados:

  • Ineficiencia de Almacenamiento: Usar CHAR(35) para nombres de ciudades de longitud variable desperdicia espacio
  • Limitación del Conjunto de Caracteres: charset latin1 inadecuado para nombres de ciudades internacionales
  • Indexación Subóptima: el índice name_key solo cubre los primeros 5 caracteres

Mejoras Sugeridas:

-- Estructura optimizada sugerida por Claude
CREATE TABLE `City` (
  `ID` int NOT NULL AUTO_INCREMENT,
  `Name` VARCHAR(35) NOT NULL,
  `CountryCode` CHAR(3) NOT NULL,
  `District` VARCHAR(20) NOT NULL,
  `Population` int UNSIGNED NOT NULL DEFAULT '0',
  PRIMARY KEY (`ID`),
  KEY `CountryCode` (`CountryCode`),
  KEY `name_idx` (`Name`),
  KEY `country_name_idx` (`CountryCode`, `Name`),
  KEY `population_idx` (`Population`),
  CONSTRAINT `city_ibfk_1` FOREIGN KEY (`CountryCode`) 
    REFERENCES `Country` (`Code`) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=4080 
  DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Análisis de Grok 3 Beta

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model grok3 "Usando un punto de vista experto en MySQL analiza esta tabla"

Grok 3 proporcionó un análisis exhaustivo y detallado cubriendo:

Análisis Técnico Profundo:

  • Análisis de Impacto en Rendimiento: Evaluó la limitación del índice parcial en detalle
  • Beneficios del Motor de Almacenamiento: Confirmó la elección de InnoDB para integridad transaccional
  • Optimización de Tipos de Datos: Recomendaciones detalladas de ahorro de espacio con ejemplos

Consideraciones Avanzadas:

  • Recomendaciones de indexación de texto completo para búsquedas de nombres de ciudades
  • Procedimientos de migración de conjunto de caracteres con comandos específicos
  • Estrategias de particionado para conjuntos de datos grandes

Guías de Implementación:

-- Sugerencia de migración de conjunto de caracteres de Grok
ALTER TABLE City CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

-- Recomendación de índice de texto completo
ALTER TABLE City ADD FULLTEXT INDEX name_fulltext (Name);

Análisis de GPT-4o

mysql --login-path=klarson world -e "show create table City\G" | \
aiml --model gpt4 "Usando un punto de vista experto en MySQL analiza esta tabla"

GPT-4o se enfocó en mejoras prácticas y directamente accionables:

Evaluación Pragmática:

  • Validó el diseño de clave primaria AUTO_INCREMENT
  • Confirmó los beneficios de restricciones de clave foránea para integridad de datos
  • Identificó limitaciones del conjunto de caracteres para aplicaciones globales

Sugerencias Listas para Implementar:

  • Comandos ALTER TABLE específicos para optimización inmediata
  • Recomendaciones de análisis de patrones de consulta
  • Criterios de evaluación de efectividad de índices

El Poder del Análisis Multi-Modelo

Lo que hace valioso este enfoque es obtener tres perspectivas distintas:

  1. Claude 4: Proporciona análisis detallado y estructurado con soluciones de código concretas
  2. Grok 3: Ofrece cobertura comprensiva con estrategias de optimización avanzadas
  3. GPT-4o: Entrega recomendaciones prácticas y directamente accionables

Cada modelo aporta fortalezas únicas:

  • Diferentes puntos focales: Optimización de almacenamiento vs. rendimiento vs. mantenibilidad
  • Niveles de profundidad variables: Desde victorias rápidas hasta mejoras arquitectónicas
  • Estilos de análisis diversos: Estructurado vs. comprensivo vs. práctico

Más Allá de MySQL: Otros Ejemplos de CLI

Ya que podemos enviar por pipe cualquier salida de comando a la herramienta de IA, aquí hay algunos otros ejemplos útiles:

Administración del Sistema

# Analizar procesos del sistema
ps aux | aiml "¿qué procesos están usando más recursos?"

# Verificar uso de disco
df -h | aiml "analiza el uso del disco y sugiere limpieza"

# Conexiones de red
netstat -tuln | aiml "explica estas conexiones de red"

# Logs del sistema
tail -50 /var/log/syslog | aiml "¿hay errores preocupantes en estos logs?"

Análisis de Archivos y Directorios

# Archivos grandes
find /var -size +100M | aiml "organiza estos archivos grandes por tipo"

# Problemas de permisos
ls -la /etc/mysql/ | aiml "verifica estos permisos de archivo para seguridad"

# Revisión de configuración
cat /etc/mysql/my.cnf | aiml "revisa esta configuración de MySQL"

Análisis de Logs

# Logs de Apache
tail -100 /var/log/apache2/error.log | aiml "resume estos errores del servidor web"

# Logs de autenticación
grep "Failed password" /var/log/auth.log | aiml "analiza estos intentos de login fallidos"

El punto es que puedes enviar por pipe casi cualquier cosa para obtener análisis rápido sin salir de tu terminal.

Implementando el Flujo de Trabajo

Instrucciones de Configuración

1. Instalar Dependencias:

# Instalar herramientas requeridas
sudo apt install curl jq mysql-client

# Crear el directorio del script
mkdir -p ~/.local/bin

# Hacer el script ejecutable
chmod +x ~/.local/bin/aiml

2. Configurar Acceso a la API:

# Obtén tu clave gratuita de AIMLAPI de https://aimlapi.com (nivel gratuito con uso limitado)
export AIMLAPI_API_KEY="tu-clave-api-gratuita-aquí"
echo 'export AIMLAPI_API_KEY="tu-clave-api-gratuita-aquí"' >> ~/.bashrc

3. Probar la Configuración:

# Verificar configuración
aiml --config

# Probar funcionalidad básica
echo "SELECT VERSION();" | aiml "explica este SQL"

Patrones de Uso Práctico

Análisis Rápido de Tabla

# Analizar una tabla específica
mysql -e "SHOW CREATE TABLE usuarios\G" mibd | \
aiml -m claude4 "Analiza esta estructura de tabla MySQL"

Comparar Diferentes Perspectivas de Modelos

# Obtener múltiples puntos de vista sobre la misma tabla
TABLE_DDL=$(mysql -e "SHOW CREATE TABLE pedidos\G" ecommerce)

echo "$TABLE_DDL" | aiml -m claude4 "análisis de tabla MySQL"
echo "$TABLE_DDL" | aiml -m grok3 "revisión de optimización de rendimiento" 
echo "$TABLE_DDL" | aiml -m gpt4 "sugerencias de mejora práctica"

Analizar Múltiples Tablas

# Análisis rápido de todas las tablas en una base de datos
mysql -e "SHOW TABLES;" mibd | \
while read tabla; do
  echo "=== Analizando $tabla ==="
  mysql -e "SHOW CREATE TABLE $tabla\G" mibd | \
  aiml -m gpt4mini "evaluación rápida de esta tabla"
done

Análisis de Índices

# Revisar uso y optimización de índices
mysql -e "SHOW INDEX FROM nombretabla;" basededatos | \
aiml -m deepseek "sugiere optimizaciones de índices para esta tabla MySQL"

Análisis de Rendimiento de Consultas

# Analizar consultas lentas
mysql -e "SHOW PROCESSLIST;" | \
aiml -m grok3 "identifica problemas potenciales de rendimiento en estos procesos MySQL"

Por Qué AIMLAPI Hace Esto Posible para DBAs

Acceso Gratuito con Costos Razonables: AIMLAPI proporciona acceso gratuito con uso limitado a más de 100 modelos de IA, con precios muy razonables para pruebas adicionales. Esto lo hace perfecto para DBAs que quieren experimentar sin comprometerse a suscripciones costosas.

Diversidad de Modelos: Acceso a modelos de diferentes proveedores (OpenAI, Anthropic, Google, Meta, etc.) significa que obtienes perspectivas variadas y áreas de expertise.

Sin Atadura a Proveedores: Puedes experimentar con diferentes modelos para encontrar lo que funciona mejor para tus necesidades específicas sin compromisos a largo plazo.

Nativo del Terminal: Se mantiene en tu ambiente cómodo de Linux donde ya estás haciendo tu trabajo de MySQL.

Guía de Selección de Modelos

Diferentes modelos sobresalen en diferentes aspectos del análisis de MySQL:

# Para análisis estructural detallado
aiml -m claude4 "revisión comprensiva de estructura de tabla"

# Para análisis enfocado en rendimiento  
aiml -m grok3 "recomendaciones de optimización de rendimiento"

# Para sugerencias rápidas y prácticas
aiml -m gpt4 "mejoras inmediatas y accionables"

# Para razonamiento complejo sobre compromisos
aiml -m deepseek-r1 "análisis de compromisos de optimización compleja"

# Para verificaciones rápidas y económicas
aiml -m gpt4mini "evaluación breve de tabla"