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:
- Extrae la estructura de la tabla desde MySQL
- La envía por pipe a nuestra herramienta de IA
- 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:
- Claude 4: Proporciona análisis detallado y estructurado con soluciones de código concretas
- Grok 3: Ofrece cobertura comprensiva con estrategias de optimización avanzadas
- 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"
