---
title: ""
canonical: "https://studiomeyer.academy/es/playbooks/welches-lokale-modell-passt-zu-deiner-hardware"
language: es
publisher: "StudioMeyer Academy, https://studiomeyer.academy (llms.txt: https://studiomeyer.academy/llms.txt)"
---

[← Alle Playbooks](https://studiomeyer.academy/playbooks)

Playbook· lokal

# Qué modelo local encaja con tu hardware

De ocho gigabytes al servidor con dos tarjetas gráficas. Cómo pasar en diez pasos de tu equipo real al tamaño de modelo correcto, en vez de adivinar y aprenderlo con el cuelgue.

La decepción más común con la IA local no es que no funcione. Es que alguien descarga el modelo más grande que ha visto recomendado en algún sitio, y entonces el ordenador o se cuelga o escupe una palabra por segundo. Después la conclusión es "lo local no sirve", cuando lo único equivocado era el tamaño.

Este playbook invierte el orden. Primero mirar tu hardware, de ahí deducir la clase de tamaño, y solo dentro de esa clase elegir según la tarea. Al final tienes dos candidatos y un método para compararlos con tu propio trabajo.

## 1\. Averigua cuánta memoria hay realmente disponible

No cuenta la memoria que lleva el equipo, sino la que el modelo recibe de verdad.

En un Mac con Apple Silicon, procesador y gráfica comparten la misma memoria, y solo una parte va al modelo. Como orientación cuenta con dos tercios a tres cuartos: de 32 GB salen unos 22 GB utilizables, de 64 GB unos 45. La proporción exacta la fija tu entorno de ejecución y ha cambiado entre versiones, así que toma la cifra como referencia y no como promesa.

Con una tarjeta gráfica dedicada cuenta solo su memoria, independientemente de cuánta RAM lleve el equipo. Tampoco ahí la tienes entera: la salida de pantalla y los controladores ocupan entre medio giga y uno. De una tarjeta de 12 GB quedan por tanto unos 11 GB. Si el modelo no cabe, una parte se descarga al procesador principal, y ahí la velocidad se hunde.

**Consejo:** Si solo te quedas con un número, quédate con este: memoria utilizable, no memoria instalada.

## 2\. Calcula el tamaño de un modelo a ojo

Una regla para el cálculo aproximado, sin buscar una tabla. Con la compresión habitual Q4, un modelo necesita aproximadamente la mitad de gigabytes que miles de millones de parámetros tiene. Un modelo de 8B queda en unos 4 a 5 GB, uno de 32B en unos 18 a 20 GB. Eso estima los pesos, no la necesidad total, y el tamaño exacto de descarga aparece de todos modos en cada modelo. Usa la fórmula para preseleccionar y la cifra real para decidir.

A eso se suma sitio para el contexto, es decir para lo que escribes y lo que el modelo retiene. Para conversaciones cortas basta con un gigabyte extra, con documentos largos bastante más.

**Consejo:** Planifica siempre dos o tres gigabytes de margen. Un modelo que cabe justo no deja sitio para tus textos y se vuelve lento con el primer documento largo.

## 3\. Sitúate en una de cuatro clases

A fecha de agosto de 2026, con la compresión habitual Q4:

Las cifras de abajo son memoria **utilizable**, o sea la VRAM de una tarjeta gráfica o la parte de Apple Silicon del paso 1, no el número de la caja.

Con **8 GB utilizables** funciona un modelo de la clase de 7 a 9 mil millones. Va, pero sin reserva para textos largos. Para resúmenes y tareas cortas basta.

Con **16 GB utilizables** se vuelve cómodo. La misma clase corre fluida con contexto decente, o subes a 14 mil millones.

Con **24 a 32 GB utilizables** llegas a la clase de 32 mil millones. Aquí lo local empieza a ser serio en contenido.

A partir de **44 GB utilizables** son posibles modelos de la clase de 70 mil millones, que con Q4 ocupan según el modelo unos 38 a 42 GB. En Apple Silicon eso convierte los 64 GB instalados en el mínimo absoluto, y va justo: con dos tercios utilizables son unos 43 GB, o sea el modelo y casi nada de contexto. Esa clase solo resulta cómoda ahí con más. Es la clase en la que dejas de notar la diferencia con la nube en cada respuesta.

**Consejo:** Estos límites se mueven, y se mueven a tu favor, porque los modelos son cada vez más eficientes. Un modelo de 30B de hoy gana a uno de 70B de hace año y medio.

## 4\. Elige dentro de tu clase según la tarea

Dentro de una clase de tamaño hay familias con puntos fuertes distintos. El panorama cambia rápido, así que aquí va el patrón en vez de un ranking que en tres meses será falso.

Para trabajo general con textos y multilingüismo, la familia Qwen de Alibaba es el estándar sólido de 2026, entre otras cosas porque muchos de sus modelos están bajo Apache 2.0 y existen en muchos tamaños. La licencia rige por modelo y por versión, no para una familia entera, así que el vistazo a la ficha del modelo sigue tocando. Para programar hay variantes coder propias dentro de las familias que, al mismo tamaño, son claramente mejores que el modelo general. Para dispositivos pequeños y memoria justa, la línea Gemma de Google está construida para la frugalidad. Quien quiera modelos que muestren su razonamiento los encuentra en las variantes de reasoning, por ejemplo la línea gpt-oss de OpenAI.

**Consejo:** No cojas nunca un modelo general para código si existe una variante coder de la misma familia. Con el mismo consumo de memoria esa diferencia es mayor que la que hay entre dos familias.

## 5\. Mira la licencia antes de que sea comercial

Pesos abiertos no significa automáticamente uso libre. Apache 2.0 y MIT son sencillas, con ellas también puedes trabajar comercialmente. Otras licencias traen restricciones, por ejemplo sobre el número de usuarios o la atribución.

Las condiciones de licencia también rigen en privado, allí solo se notan menos. En cuanto hay un cliente de por medio o el modelo va dentro de un producto, la formalidad se convierte en riesgo.

**Consejo:** La licencia está en la ficha del modelo en Hugging Face. Un vistazo, treinta segundos, te ahorra una pregunta incómoda en una reunión comercial.

## 6\. Descarga dos candidatos, no uno

El error es decidir de antemano. Descarga dos modelos de tu clase que vengan de familias distintas. El espacio no te cuesta nada permanente, y comparar con tu propio trabajo vale más que cualquier ranking.

**Consejo:** No cojas dos tamaños de la misma familia. Ahí gana el grande de forma previsible. Coge dos familias distintas al mismo tamaño, esa es la pregunta que de verdad tienes.

## 7\. Constrúyete diez casos de prueba propios

Reúne diez tareas de tu día a día en las que puedas juzgar si el resultado sirve. Reformular un correo, resumir un acta, interpretar una tabla, lo que realmente hagas.

Ponlas en un archivo y manda cada una a los dos modelos. No valores mientras lees. Recoge primero las veinte respuestas y luego repásalas.

**Consejo:** Incluye tareas que a los modelos en la nube les cuesten. Ahí es justo donde se ve si lo local te basta.

## 8\. Mide la velocidad, pero la correcta

Dos cifras pesan de forma distinta. El tiempo hasta la primera palabra lo notas enseguida en una conversación. Las palabras por segundo después solo las notas si bajan de tu velocidad de lectura.

Un modelo que arranca al segundo y luego escribe con ritmo se siente mejor que uno que piensa tres segundos y luego teclea más rápido. Para procesamiento masivo en segundo plano es justo al revés, ahí solo cuenta el rendimiento total.

**Consejo:** Mi límite personal está en unas diez palabras por segundo, más o menos la velocidad de lectura. Por debajo el trabajo se siente pesado. No es una norma medida sino una regla práctica; los entornos de ejecución informan de tokens y no de palabras, y el alemán necesita más tokens por palabra que el inglés. Si se siente pesado, baja una clase, el resultado global mejora.

## 9\. Decídete y escribe el motivo

Elige el modelo que te haya convencido más veces en tus diez casos. No el de mejores números en benchmarks, no el que recomendaban en un foro.

Anota en dos frases por qué. Necesitarás esa nota dentro de tres meses, cuando llegue la siguiente generación y compares de nuevo. Entonces tendrás listos tanto los casos como el criterio.

**Consejo:** Guarda los diez casos de prueba. Son tu benchmark personal y valen más que cualquier ranking público, porque miden tu trabajo y no el de otro.

## 10\. Cuenta con el cambio desde el principio

El modelo que elijas hoy no será el mejor dentro de medio año. Eso no es problema mientras no lo hayas cableado a fuego.

Mantén el nombre del modelo en un solo sitio de tu configuración, no repartido por diez scripts. Entonces cambiar es una línea. Quien escribe el nombre en todas partes deja de cambiar por comodidad y acaba trabajando dos generaciones por detrás.

**Consejo:** El mismo principio vale para los modelos en la nube. Cómo enterarse siquiera de los lanzamientos, en vez de descubrirlos por casualidad, está en [Seguir la disponibilidad de modelos](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken).

## Qué sigue

Si aún no tienes ningún modelo funcionando, empieza por [Tu primer modelo de IA local en 30 minutos](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten). Si la cuestión del hardware está resuelta y ahora se trata del uso en la empresa, [IA local y el RGPD](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) cubre la parte legal. Y si quieres saber si tu propio equipo compensa frente a la nube, las cuentas están en [Local o nube, las cuentas honestas](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung).

## Fuentes

Las cifras de memoria son aproximaciones con compresión Q4, a fecha de agosto de 2026, y varían según la arquitectura del modelo y la longitud del contexto. Comprueba el valor concreto en la ficha del modelo.

- Ollama, biblioteca de modelos con tamaños: https://ollama.com/library
- Hugging Face, fichas de modelo con licencia y pesos: https://huggingface.co/models
- llama.cpp, documentación sobre niveles de cuantización: https://github.com/ggml-org/llama.cpp

[← Tu primer modelo de IA local e](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [IA local y el RGPD, qué resuel →](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo)

Alle Playbooks

[01. De ChatGPT a Claude, guía en 10 pasos](https://studiomeyer.academy/playbooks/von-chatgpt-zu-claude) [02. De ChatGPT a Codex, guía en 10 pasos](https://studiomeyer.academy/playbooks/von-chatgpt-zu-codex) [03. Tu primer servidor MCP en 90 minutos](https://studiomeyer.academy/playbooks/erster-mcp-server-in-90-minuten) [04. Memoria portable, la misma memoria en Claude, Codex y Cursor](https://studiomeyer.academy/playbooks/memory-portabel-nutzen) [05. DACH legal. EU AI Act y GDPR para operadores de IA](https://studiomeyer.academy/playbooks/dach-legal-eu-ai-act-und-dsgvo) [06. Tu primer sub-agente en 30 minutos](https://studiomeyer.academy/playbooks/erster-sub-agent-in-30-min) [07. Publicar un servidor MCP paso a paso](https://studiomeyer.academy/playbooks/mcp-server-publishen) [08. Hooks contra alucinaciones](https://studiomeyer.academy/playbooks/hooks-gegen-halluzinationen) [09. Git para IA, quickstart en 30 minutos](https://studiomeyer.academy/playbooks/git-fuer-ki-quickstart) [10. Agents programados con Claude Code routines](https://studiomeyer.academy/playbooks/scheduled-agents-mit-routines) [11. Evitar el tool sprawl, de 530 a 30 MCP tools por sesión](https://studiomeyer.academy/playbooks/tool-sprawl-vermeiden) [12. Estrategia de updates de Claude Code, sin que tu workflow se rompa de golpe](https://studiomeyer.academy/playbooks/claude-code-update-strategie) [12. Estructurar tu equipo de subagentes, los seis roles que necesitas en el día a día](https://studiomeyer.academy/playbooks/subagent-team-strukturieren) [13. Cost controls de Claude Code para uso diario, quedarte bajo 30 dólares al día en 10 pasos](https://studiomeyer.academy/playbooks/claude-code-cost-controls-fuer-daily-driver) [14. Tus propios slash commands para Claude Code, productivo en 30 minutos](https://studiomeyer.academy/playbooks/eigene-slash-commands-fuer-claude-code) [15. Claude Code headless en CI/CD, un setup que ya corre mañana](https://studiomeyer.academy/playbooks/claude-code-headless-in-ci-cd) [16. Eval de agente en 60 minutos, cómo saber si tu agente es bueno](https://studiomeyer.academy/playbooks/agent-eval-in-60-minuten) [17. Plan Mode en Claude Code, el cinturón invisible, cuándo lo necesitas y cómo dejarlo puesto](https://studiomeyer.academy/playbooks/plan-mode-richtig-nutzen) [18. Depurar MCP cuando nada funciona, los 10 checks que resuelven el 90 por ciento de los casos](https://studiomeyer.academy/playbooks/mcp-debuggen-wenn-nichts-geht) [18. Dominar el prompt caching, de cache miss al 80 por ciento de aciertos en 10 pasos](https://studiomeyer.academy/playbooks/prompt-caching-meistern) [19. Reparar memory drift, cuando la memoria de tu agente empieza a contradecirse](https://studiomeyer.academy/playbooks/memory-drift-reparieren) [20. Seguridad de MCP STDIO, qué significa para ti la historia de OX Security](https://studiomeyer.academy/playbooks/mcp-stdio-sicherheit) [21. Migración a Opus 4.7, qué cambió para builders de API](https://studiomeyer.academy/playbooks/opus-4-7-migration) [22. Tu primer Skill en 30 minutos, cuando los slash commands ya no bastan](https://studiomeyer.academy/playbooks/erste-eigene-skill-in-30-min) [23. Gestionar la ventana de contexto en sesiones largas de Claude Code](https://studiomeyer.academy/playbooks/context-window-managen-claude-code) [24. Advisor Tool, Opus como asesor y Sonnet como ejecutor en una sola llamada API](https://studiomeyer.academy/playbooks/advisor-tool-opus-als-berater-sonnet-als-executor) [25. Asegura tu servidor MCP con OAuth 2.1 en 60 minutos](https://studiomeyer.academy/playbooks/mcp-server-auth-mit-oauth-2-1) [26. Distribuir plugin bundles via URL, --plugin-url en 30 minutos](https://studiomeyer.academy/playbooks/plugin-bundle-via-url-distribution) [27. Claude Code en equipo, cómo mantener vivo CLAUDE.md sin que se convierta en un cubo de basura](https://studiomeyer.academy/playbooks/claude-code-im-team-claude-md-gemeinsam-pflegen) [27. Cargar plugins ajenos de Claude Code desde ZIP y URL, seguro en 20 minutos](https://studiomeyer.academy/playbooks/claude-code-plugins-aus-zip-und-url-laden) [28. Auditoría de confused deputy para Claude Code, hecha en 25 minutos](https://studiomeyer.academy/playbooks/confused-deputy-audit-fuer-claude-code) [28. Tu primer plugin de Claude Code en 60 minutos, de la carpeta vacía al bundle instalable](https://studiomeyer.academy/playbooks/dein-erstes-claude-code-plugin) [29. Pull request reviews con Claude Code, 10 pasos para un workflow de PR que nadie bloquea ya](https://studiomeyer.academy/playbooks/pull-request-reviews-mit-claude-code) [30. Claude Projects para no-coders, un workspace productivo en 30 minutos](https://studiomeyer.academy/playbooks/claude-projects-fuer-nicht-coder) [31. Construir una biblioteca de prompts, reutilizar tus prompts favoritos sin copy-paste](https://studiomeyer.academy/playbooks/prompt-bibliothek-aufbauen) [32. Output Styles para Claude Code, un tono propio en 20 minutos](https://studiomeyer.academy/playbooks/output-styles-fuer-claude-code) [33. Statusline para Claude Code, contexto a la vista en 15 minutos](https://studiomeyer.academy/playbooks/statusline-fuer-claude-code) [34. Checkpoints y /rewind en Claude Code: tu red de seguridad para ediciones arriesgadas](https://studiomeyer.academy/playbooks/claude-code-checkpoints-und-rewind) [34. Mantener coherentes los discovery files para que los crawlers de IA no citen bios viejas y falsas](https://studiomeyer.academy/playbooks/discovery-files-konsistent-halten) [34. Depurar hooks cuando no se dispara nada](https://studiomeyer.academy/playbooks/hooks-debuggen-wenn-nichts-feuert) [34. Sesiones paralelas de Claude Code con git worktrees, dos ramas a la vez sin conflicto](https://studiomeyer.academy/playbooks/parallele-claude-sessions-mit-worktrees) [34. La skill no se dispara, qué comprobar en 10 pasos antes de volver a teclear /comando](https://studiomeyer.academy/playbooks/skill-trigger-debugging) [34. Sub-agente o skill o herramienta MCP, ¿cuál eliges y cuándo?](https://studiomeyer.academy/playbooks/sub-agent-oder-skill-oder-mcp-tool) [35. Llevar sesiones paralelas de Claude Code con git worktrees](https://studiomeyer.academy/playbooks/claude-code-mit-git-worktrees) [35. Backup de memoria antes de actualizar, para que no llores por un bug de migración de esquema](https://studiomeyer.academy/playbooks/memory-backup-vor-update) [36. AGENTS.md junto a CLAUDE.md, un contexto de repo para varias herramientas de IA](https://studiomeyer.academy/playbooks/agents-md-neben-claude-md) [47. Generative Engine Optimization para sitios pequeños, para que Perplexity y ChatGPT-Search te citen](https://studiomeyer.academy/playbooks/geo-fuer-kleine-sites) [50. Migración a Opus 4.8, la primera actualización de Opus sin breaking changes](https://studiomeyer.academy/playbooks/opus-4-8-migration) [51. Sesiones en segundo plano con agentes de Claude: ejecuta tareas largas sin bloquear tu terminal](https://studiomeyer.academy/playbooks/background-sessions-mit-claude-agents) [52. Configura la sandbox de bash de Claude Code: aísla comandos en vez de permitirlos a ciegas](https://studiomeyer.academy/playbooks/claude-code-bash-sandbox-einrichten) [53. Del script a tu propio agente: el Claude Agent SDK en 90 minutos](https://studiomeyer.academy/playbooks/claude-agent-sdk-erster-eigener-agent) [54. Crea una MCP App: UI interactiva en tu herramienta MCP en lugar de un muro de texto](https://studiomeyer.academy/playbooks/mcp-app-interaktive-ui-bauen) [55. El mito del modelo caro: cuándo merece la pena de verdad el modelo de IA más caro](https://studiomeyer.academy/playbooks/mythos-klasse-wann-lohnt-sich-das) [56. Configurar modelos de fallback para que Claude Code no se quede colgado en sobrecarga](https://studiomeyer.academy/playbooks/claude-code-fallback-modelle) [57. Dynamic workflows en Claude Code, tu primer script multiagente orquestado](https://studiomeyer.academy/playbooks/dynamic-workflows-in-claude-code) [58. Plugin security-guidance para Claude Code, revisión de seguridad automática mientras construyes](https://studiomeyer.academy/playbooks/claude-code-security-guidance-plugin) [59. Claude Code falla tras un cambio de configuración, cómo encontrar la causa](https://studiomeyer.academy/playbooks/claude-code-safe-mode-diagnose) [60. MCP es stateless: qué cambia la spec 2026-07-28 y qué tienes que hacer ahora](https://studiomeyer.academy/playbooks/mcp-spec-2026-07-was-aendert-sich) [61. Tu primer flujo real en n8n: automatización para quienes no programan](https://studiomeyer.academy/playbooks/mein-erster-n8n-flow-fuer-nicht-coder) [62. Pagos agénticos con x402, lo que un builder debe saber sobre APIs pagadas por máquinas](https://studiomeyer.academy/playbooks/agentic-payments-x402) [63. GPT-5.6 u Opus 5, qué modelo para qué tarea](https://studiomeyer.academy/playbooks/gpt-5-oder-opus-4-8-welches-modell) [64. Subagents que generan subagents, la regla de 5 niveles de Claude Code](https://studiomeyer.academy/playbooks/subagents-die-subagents-spawnen) [65. Configurar agent teams en Claude Code, varias sesiones que se ayudan entre sí](https://studiomeyer.academy/playbooks/claude-code-agent-teams-einrichten) [66. Rastrear la disponibilidad de modelos, cuando un modelo desaparece de la noche a la mañana](https://studiomeyer.academy/playbooks/modell-verfuegbarkeit-tracken) [67. Protección de datos al trabajar con herramientas de IA: diez hábitos que te protegen](https://studiomeyer.academy/playbooks/datenschutz-mit-ki-tools) [68. Usar Auto Mode en Claude Code con seguridad, en 10 pasos sin comandos suicidas](https://studiomeyer.academy/playbooks/claude-code-auto-mode-sicher-nutzen) [69. IA para la búsqueda de empleo: 10 pasos para pasar el filtro ATS](https://studiomeyer.academy/playbooks/ki-fuer-jobsuche) [70. Construye en 10 pasos un portafolio de IA que te consiga trabajo](https://studiomeyer.academy/playbooks/ai-portfolio-fuer-den-job) [71. Demostrar tus habilidades de IA de forma creíble en el CV y la entrevista](https://studiomeyer.academy/playbooks/ai-skills-belegen-lebenslauf-interview) [72. Niveles de effort en Claude Code, cuándo basta low y cuándo necesitas max](https://studiomeyer.academy/playbooks/effort-level-in-claude-code-einstellen) [73. Del skill de la Academy al primer encargo de IA pagado](https://studiomeyer.academy/playbooks/erster-bezahlter-ki-auftrag) [74. Verificar una respuesta de IA: 10 pasos contra la información falsa](https://studiomeyer.academy/playbooks/ki-antwort-faktenchecken) [75. Imágenes de IA para tu marca, del primer prompt al set terminado](https://studiomeyer.academy/playbooks/ki-bilder-fuer-deine-marke) [76. IA para autónomos, escribir presupuestos y correos a clientes en la mitad de tiempo](https://studiomeyer.academy/playbooks/ki-fuer-selbststaendige-angebote-und-mails) [77. Detectar y etiquetar correctamente el contenido de IA](https://studiomeyer.academy/playbooks/ki-inhalte-erkennen-und-kennzeichnen) [78. Notas de reuniones con IA que de verdad sirven](https://studiomeyer.academy/playbooks/ki-notizen-fuer-meetings) [79. IA local en tu propio ordenador, para que tus datos nunca salgan de casa](https://studiomeyer.academy/playbooks/lokale-ki-auf-dem-eigenen-rechner) [80. Entender las tres primitivas de MCP. Tools, Resources y Prompts](https://studiomeyer.academy/playbooks/mcp-primitives-tools-resources-prompts) [81. JSON fiable de cualquier IA, para que tu automatización no se rompa](https://studiomeyer.academy/playbooks/verlaessliches-json-aus-ai) [82. Lo que cuestan de verdad las herramientas de IA, y dónde acechan las facturas ocultas](https://studiomeyer.academy/playbooks/was-kostet-ki-wirklich) [83. Entender la prompt injection, las tres trampas cuando tu asistente de IA lee textos ajenos](https://studiomeyer.academy/playbooks/prompt-injection-erkennen) [84. Protegerte del fraude con IA, llamadas falsas, phishing y ofertas de empleo falsas](https://studiomeyer.academy/playbooks/dich-vor-ki-betrug-schuetzen) [85. Migración a Opus 5, cuando pensar pasa a ser lo normal](https://studiomeyer.academy/playbooks/opus-5-migration) [86. La política de IA para equipos pequeños, en una sola página](https://studiomeyer.academy/playbooks/ki-richtlinie-fuer-kleine-teams) [87. Frenar a los agentes que se desvían](https://studiomeyer.academy/playbooks/agenten-die-abdriften-stoppen) [88. Ver qué hizo realmente tu agente, tracing en 10 pasos con OpenTelemetry](https://studiomeyer.academy/playbooks/agent-tracing-mit-opentelemetry) [89. Que la IA resuma documentos largos sin que se invente cosas](https://studiomeyer.academy/playbooks/lange-dokumente-sicher-zusammenfassen) [90. Revisar servidores MCP ajenos con seguridad antes de instalarlos](https://studiomeyer.academy/playbooks/fremde-mcp-server-sicher-pruefen) [91. La IA como coach de aprendizaje: aprender un campo nuevo para cambiar de profesión](https://studiomeyer.academy/playbooks/ki-lern-coach-berufswechsel) [92. El perfil de AI operator: ¿en qué consiste realmente?](https://studiomeyer.academy/playbooks/berufsbild-ai-operator) [93. Usar la IA sin perder tu propio criterio](https://studiomeyer.academy/playbooks/ki-nutzen-ohne-selbst-zu-verlernen) [94. Por qué tu captura se encoge y cómo controlarlo](https://studiomeyer.academy/playbooks/bilder-und-screenshots-an-die-ki-geben) [95. Formular un encargo de deep research para que el informe valga algo](https://studiomeyer.academy/playbooks/deep-research-auftrag-formulieren) [96. Analizar cifras y tablas con IA sin acabar con disparates](https://studiomeyer.academy/playbooks/zahlen-und-tabellen-mit-ki-auswerten) [97. Leer benchmarks de IA sin que te tomen el pelo](https://studiomeyer.academy/playbooks/ki-benchmarks-richtig-lesen) [98. La IA como sparring, mejores decisiones en vez de amable aprobación](https://studiomeyer.academy/playbooks/ki-als-sparringspartner-fuer-entscheidungen) [99. Aprender una habilidad nueva con IA, por el camino honesto](https://studiomeyer.academy/playbooks/mit-ki-neue-faehigkeit-lernen) [100. Cambiar tu servidor MCP sin romper a los usuarios](https://studiomeyer.academy/playbooks/mcp-server-aendern-ohne-nutzer-zu-brechen) [101. Tu primer modelo de IA local en 30 minutos](https://studiomeyer.academy/playbooks/erstes-lokales-modell-in-30-minuten) [102. Qué modelo local encaja con tu hardware](https://studiomeyer.academy/playbooks/welches-lokale-modell-passt-zu-deiner-hardware) [103. IA local y el RGPD, qué resuelve de verdad y qué no](https://studiomeyer.academy/playbooks/lokale-ki-und-die-dsgvo) [104. MCP con modelos locales, herramientas sin nube](https://studiomeyer.academy/playbooks/mcp-mit-lokalen-modellen) [105. Local o nube, las cuentas honestas](https://studiomeyer.academy/playbooks/lokal-oder-cloud-die-ehrliche-rechnung) [106. Cuando el repo de otro configura tu IA. El caso ChainDrop](https://studiomeyer.academy/playbooks/agent-konfiguration-als-angriffsweg) [107. Transcribir conversaciones sin conexión, sin que salgan de casa](https://studiomeyer.academy/playbooks/gespraeche-offline-transkribieren) [108. Conectar n8n con un modelo local](https://studiomeyer.academy/playbooks/n8n-mit-lokalem-modell-verbinden) [109. Leer documentos sin conexión, cuando el escaneo no se puede subir](https://studiomeyer.academy/playbooks/dokumente-offline-auslesen) [→ Zur Academy](https://studiomeyer.academy/levels/1)

## Sitemap

Páginas públicas de este sitio como Markdown: [sitemap](https://studiomeyer.academy/sitemap.md). Punto de entrada curado: [llms.txt](https://studiomeyer.academy/llms.txt), texto completo: [llms-full.txt](https://studiomeyer.academy/llms-full.txt).