La base técnica para que la IA pueda leerte y citarte

Qué necesita un motor de IA de tu sitio

Tres cosas: poder rastrear la página, poder leer el texto en el HTML sin ejecutar JavaScript, y entender sin ambigüedad quién la publica y qué responde. Si falla cualquiera de las tres, ni el mejor contenido te sirve.

Cuando un motor de IA busca en vivo para responder una pregunta, hace algo muy parecido a lo que hace un buscador: descarga páginas, extrae su texto y decide cuáles usar. En el capítulo 1 vimos ese proceso con detalle. Aquí nos concentramos en las capas técnicas que hacen posible que tu sitio entre en esa selección.

La buena noticia es que casi todo esto se configura una vez. La mala es que un solo error, como un canonical mal puesto o un firewall que bloquea bots, puede anular todo lo demás sin que te des cuenta. En el capítulo 6 cuento cómo un error así dejó a este mismo sitio con unas tres visitas al mes.

Bots de IA en robots.txt

Cada empresa de IA usa bots distintos para entrenar modelos y para buscar en vivo. Puedes bloquear el entrenamiento y permitir la búsqueda. Si quieres que te citen, nunca bloquees los bots de búsqueda: OAI-SearchBot, Claude-SearchBot, PerplexityBot y, por supuesto, Googlebot y Bingbot.

El archivo robots.txt le dice a cada rastreador qué puede visitar. Hasta hace poco bastaba con pensar en Googlebot y Bingbot. Hoy cada empresa de IA tiene varios agentes con propósitos diferentes, y confundirlos es la causa más común de que una marca desaparezca de las respuestas.

Las fuentes oficiales son la documentación de bots de OpenAI, el artículo de soporte de Anthropic sobre sus rastreadores, la guía de bots de Perplexity y la lista de rastreadores de Google.

La decisión: entrenamiento sí o no

La pregunta que debes responder no es “¿bloqueo la IA?”, sino “¿quiero que mi contenido entrene modelos?”. Son dos cosas distintas. Bloquear el entrenamiento puede tener sentido si vendes contenido de pago, como cursos o investigación. Para la mayoría de empresas de servicios, que quieren que las recomienden, lo razonable es permitir todo: que el modelo aprenda quién eres también ayuda a que te mencione cuando responde desde su memoria.

User-agent: *
Allow: /
Disallow: /admin/
Disallow: /api/

# Bots de búsqueda y de entrenamiento de IA: permitidos
User-agent: OAI-SearchBot
User-agent: GPTBot
User-agent: ChatGPT-User
User-agent: Claude-SearchBot
User-agent: ClaudeBot
User-agent: Claude-User
User-agent: PerplexityBot
Allow: /

Sitemap: https://tudominio.com/sitemap.xml

User-agent: *
Allow: /

# Entrenamiento: bloqueado
User-agent: GPTBot
User-agent: ClaudeBot
User-agent: Google-Extended
Disallow: /

# Búsqueda: permitida (no hace falta listarlos si "*" ya permite,
# pero dejarlos explícitos evita errores al editar)
User-agent: OAI-SearchBot
User-agent: Claude-SearchBot
User-agent: PerplexityBot
Allow: /

Sitemap: https://tudominio.com/sitemap.xml

Un detalle que confunde: si un bot tiene su propio grupo User-agent, ignora las reglas del grupo *. Por eso, si bloqueas un bot por nombre, debes repetir dentro de su grupo cualquier regla que también quieras aplicarle.

En Next.js (App Router)

Puedes servir un public/robots.txt estático o generarlo con app/robots.ts. La documentación de Next.js describe el formato. Usa uno de los dos, no ambos.

import type { MetadataRoute } from 'next';

export default function robots(): MetadataRoute.Robots {
  return {
    rules: [
      { userAgent: '*', allow: '/', disallow: ['/admin/', '/api/'] },
      {
        userAgent: ['OAI-SearchBot', 'ChatGPT-User', 'Claude-SearchBot', 'Claude-User', 'PerplexityBot'],
        allow: '/',
      },
      // Descomenta si NO quieres que tu contenido entrene modelos:
      // { userAgent: ['GPTBot', 'ClaudeBot', 'Google-Extended'], disallow: '/' },
    ],
    sitemap: 'https://tudominio.com/sitemap.xml',
  };
}

En WordPress

WordPress genera un robots.txt virtual si no existe un archivo físico en la raíz. Tienes tres caminos: subir un robots.txt físico por FTP o el administrador de archivos del hosting, editarlo desde tu plugin de SEO (Yoast y Rank Math tienen un editor), o agregar reglas con el filtro robots_txt:

add_filter( 'robots_txt', function ( $output, $public ) {
    $output .= "\nUser-agent: OAI-SearchBot\nUser-agent: Claude-SearchBot\nUser-agent: PerplexityBot\nAllow: /\n";
    return $output;
}, 10, 2 );

Que el contenido esté en el HTML

Los principales rastreadores de IA no ejecutan JavaScript. Si tu texto solo aparece después de que el navegador ejecuta código, para ellos la página está vacía. Sirve el contenido en el HTML desde el servidor.

En diciembre de 2024, Vercel publicó un análisis del tráfico de rastreadores en su red y concluyó que ninguno de los principales rastreadores de IA renderiza JavaScript, incluyendo GPTBot, ClaudeBot y PerplexityBot. Descargan los archivos JavaScript pero no los ejecutan. El mismo análisis señala que Gemini aprovecha la infraestructura de Googlebot, que sí renderiza.

Las consecuencias prácticas son claras:

• Una aplicación de una sola página (SPA) hecha solo con React, Vue o Angular en el navegador puede ser invisible para ChatGPT o Claude, aunque Google la indexe bien.
• Pestañas, acordeones o “ver más” que cargan el texto con una petición al hacer clic esconden ese texto. Si el contenido ya está en el HTML y solo se oculta con CSS, no hay problema.
• Precios, horarios o datos de contacto que se pintan con un widget de terceros tampoco se ven.

En Next.js, las páginas del App Router son componentes de servidor por defecto: el HTML llega completo. El riesgo aparece cuando marcas una página entera con 'use client' y traes los datos con useEffect. En WordPress el HTML se genera en el servidor, así que el riesgo está en los constructores visuales o plugins que cargan secciones con AJAX.

# Debe devolver un número mayor que 0
curl -s -A "GPTBot" https://tudominio.com/servicios | grep -c "una frase que esté en la página"

Canonical: el error que te borra

La etiqueta canonical le dice a los buscadores cuál es la URL oficial de una página. Cada página debe apuntar a sí misma. Si todas apuntan a la página de inicio, le estás diciendo a Google que el resto del sitio son copias, y las deja fuera.

Este es el error técnico más silencioso y más destructivo que he visto. Un canonical global, puesto una sola vez en la plantilla o en el layout raíz, se copia en todas las páginas. El sitio se ve perfecto para las personas, pero los buscadores entienden que solo existe la página de inicio. Y como varios motores de IA buscan sobre índices como el de Google y el de Bing, el efecto se traslada a las respuestas de IA.

En Next.js

El error típico es poner alternates.canonical en app/layout.tsx. Ese valor lo heredan todas las rutas que no lo sobrescriben. Lo correcto es definir metadataBase en el layout y un canonical relativo en cada página:

export const metadata: Metadata = {
  metadataBase: new URL('https://tudominio.com'),
  title: { default: 'Tu marca', template: '%s | Tu marca' },
  // NO pongas alternates.canonical aquí
};

export const metadata: Metadata = {
  title: 'Servicios',
  alternates: { canonical: '/servicios' },
};

Para rutas dinámicas, como app/blog/[slug]/page.tsx, genera el canonical en generateMetadata con el slug. La API está en la referencia de metadata de Next.js.

En WordPress

WordPress imprime un canonical en las entradas y páginas individuales, y Yoast o Rank Math lo controlan en todo el sitio. Los problemas aparecen cuando dos plugins lo imprimen a la vez, cuando alguien pega un canonical a mano en el encabezado del tema o cuando el campo “URL canónica” de una entrada se llenó por error. Revisa el código fuente de varias páginas, no solo de la portada.

Junto al canonical, unifica la versión del dominio: decide si usas www o no, y redirige la otra con un 301. Lo mismo con http a https.

Sitemap con fechas reales

El sitemap lista las URL que quieres que se rastreen, con su fecha de última modificación. Mantenlo automático, con solo URL canónicas que respondan 200 y con fechas que cambien solo cuando cambia el contenido.

Un sitemap no te hace aparecer por sí solo, pero acelera el descubrimiento de páginas nuevas y les da a los buscadores una señal de qué cambió. La fecha lastmod pierde valor si la pones igual a “hoy” en todas las URL cada vez que se genera el archivo: los buscadores aprenden a ignorarla.

En Next.js

import type { MetadataRoute } from 'next';
import { getPosts } from '@/lib/posts';

const BASE = 'https://tudominio.com';

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const posts = await getPosts();
  return [
    { url: BASE, lastModified: new Date('2026-10-19') },
    { url: `${BASE}/servicios`, lastModified: new Date('2026-09-02') },
    ...posts.map((p) => ({ url: `${BASE}/blog/${p.slug}`, lastModified: p.updatedAt })),
  ];
}

Detalles en la documentación de sitemap de Next.js.

En WordPress

Desde la versión 5.5, WordPress publica un índice de sitemaps en /wp-sitemap.xml. Si usas Yoast o Rank Math, ellos lo reemplazan por el suyo (normalmente /sitemap_index.xml). Verifica que no incluyan etiquetas, adjuntos o páginas de autor que no quieres indexar.

En ambos casos, envía el sitemap en Google Search Console y en Bing Webmaster Tools. Bing importa más de lo que parece: es una de las fuentes de Copilot y de otros servicios que buscan en la web.

Schema: Person, Organization y FAQPage

El schema en JSON-LD describe en un formato estándar quién eres, qué publicas y qué responde cada página. Los tres tipos que más ayudan a la visibilidad en IA son Person u Organization (la entidad), Article (el contenido) y FAQPage (las preguntas que respondes).

Los modelos leen texto, pero el schema reduce la ambigüedad. Si en tu sitio dice “Cristian Parada” y en LinkedIn dice “Cristian Parada, Zero Azul”, el marcado con sameAs le dice a cualquier sistema que son la misma persona. Esa coherencia de entidad es la base del capítulo 5.

Person (marca personal)

Ponlo una sola vez, en el layout raíz, con un @id estable. Después, cada artículo lo referencia por ese @id en lugar de repetir los datos. La referencia del tipo está en schema.org/Person.

{
  "@context": "https://schema.org",
  "@type": "Person",
  "@id": "https://tudominio.com#person",
  "name": "Nombre Apellido",
  "jobTitle": "Consultor en inteligencia artificial",
  "url": "https://tudominio.com",
  "image": "https://tudominio.com/foto.jpg",
  "worksFor": { "@id": "https://tuempresa.com#organization" },
  "address": { "@type": "PostalAddress", "addressLocality": "Medellín", "addressCountry": "CO" },
  "knowsAbout": ["Inteligencia artificial", "Automatización", "Transformación digital"],
  "sameAs": [
    "https://www.linkedin.com/in/tu-perfil",
    "https://www.youtube.com/@tucanal"
  ]
}

Organization (empresa)

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://tuempresa.com#organization",
  "name": "Tu Empresa",
  "legalName": "Tu Empresa S.A.S.",
  "url": "https://tuempresa.com",
  "logo": "https://tuempresa.com/logo.png",
  "foundingDate": "2015",
  "founder": { "@id": "https://tudominio.com#person" },
  "address": { "@type": "PostalAddress", "addressLocality": "Medellín", "addressCountry": "CO" },
  "sameAs": [
    "https://www.linkedin.com/company/tu-empresa",
    "https://www.google.com/maps?cid=TU_CID"
  ]
}

Si tienes un local que atiende público, usa LocalBusiness o un subtipo más preciso en lugar de Organization. Ver schema.org/Organization.

FAQPage

En agosto de 2023 Google anunció que mostraría los resultados enriquecidos de preguntas frecuentes solo para sitios oficiales de gobierno y de salud. Eso no hace inútil el marcado: sigue diciendo de forma explícita qué preguntas responde la página, y las preguntas visibles en la página siguen siendo un formato muy fácil de extraer. La regla de oro: el texto del schema debe ser idéntico al que se ve en la página. Referencia: schema.org/FAQPage.

const faq = [
  { q: '¿Cuánto cuesta…?', a: 'Depende de…' },
];

const jsonLd = {
  '@context': 'https://schema.org',
  '@graph': [
    {
      '@type': 'Article',
      headline: 'Título del artículo',
      datePublished: '2026-10-19',
      dateModified: '2026-10-19',
      author: { '@id': 'https://tudominio.com#person' },
    },
    {
      '@type': 'FAQPage',
      mainEntity: faq.map((f) => ({
        '@type': 'Question',
        name: f.q,
        acceptedAnswer: { '@type': 'Answer', text: f.a },
      })),
    },
  ],
};

export default function Page() {
  return (
    <>
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
      />
      {/* …el mismo faq renderizado como texto visible… */}
    </>
  );
}

add_action( 'wp_head', function () {
    $data = array(
        '@context' => 'https://schema.org',
        '@type'    => 'Person',
        '@id'      => home_url( '#person' ),
        'name'     => 'Nombre Apellido',
        'url'      => home_url( '/' ),
        'sameAs'   => array( 'https://www.linkedin.com/in/tu-perfil' ),
    );
    echo '<script type="application/ld+json">' . wp_json_encode( $data ) . '</script>';
} );

En WordPress revisa primero qué genera ya tu plugin de SEO: Yoast y Rank Math crean un grafo con Organization o Person, WebSite y Article. Duplicarlo con código propio crea dos entidades distintas. Lo correcto es completar los datos en el plugin (logo, redes, tipo de entidad) y agregar código solo para lo que el plugin no cubre. Valida todo con el validador de schema.org y la prueba de resultados enriquecidos de Google.

llms.txt: qué es y qué no es

llms.txt es un archivo en Markdown en la raíz del sitio que resume quién eres y enlaza tus páginas más importantes, pensado para que un modelo lo lea rápido. Es una propuesta abierta, no un estándar: los grandes buscadores no han dicho que lo usen para posicionar. Créalo si te toma 20 minutos, no lo trates como prioridad.

Jeremy Howard publicó la propuesta en llmstxt.org en septiembre de 2024. El único elemento obligatorio es el título. El formato es simple: un título con el nombre del sitio, una cita en bloque con el resumen y secciones con listas de enlaces. Algunas herramientas de documentación y agentes de programación lo leen. Para los buscadores generales, la señal sigue siendo tu HTML: la página de Google sobre funciones de IA y tu sitio web dice que no necesitas crear archivos de texto para IA ni marcado nuevo para aparecer en AI Overviews o AI Mode. Y en abril de 2025 John Mueller, de Google, lo comparó con la antigua meta etiqueta de palabras clave, según Search Engine Journal.

# Cristian Parada

> Consultor de inteligencia artificial y transformación digital en Medellín, Colombia.
> CEO de Zero Azul. Ayuda a empresas a implementar IA con Claude, ChatGPT y Copilot.

## Servicios
- [Contratar consultoría](https://cristianparada.com/contratar): formatos y cómo trabajar juntos
- [Conferencias](https://cristianparada.com/conferencista): charlas sobre IA para empresas

## Guías
- [Guía de visibilidad en motores de IA](https://cristianparada.com/guias/visibilidad-en-ia): cómo lograr que ChatGPT, Gemini y Perplexity recomienden tu marca

## Herramientas
- [Calculadora de ahorro con IA](https://cristianparada.com/herramientas/calculadora-ahorro-ia)

En Next.js basta con guardarlo en public/llms.txt. En WordPress, súbelo a la carpeta raíz de la instalación, junto a wp-config.php. Verifica que responda en https://tudominio.com/llms.txt con tipo de contenido de texto.

Velocidad y Core Web Vitals

La velocidad no hace que una IA te cite, pero una página lenta o inestable rinde peor en la Búsqueda, y la Búsqueda alimenta a varios motores de IA. Apunta a los umbrales de Google: LCP de 2,5 segundos o menos, INP de 200 milisegundos o menos y CLS de 0,1 o menos.

Google define los umbrales de “bueno” para las Core Web Vitals medidos en el percentil 75 de las visitas reales:

Lo que más mueve la aguja, en orden:

1. Imágenes en formatos modernos (WebP o AVIF), con ancho y alto declarados, y carga diferida fuera de la primera pantalla.
2. Menos JavaScript de terceros: chats, mapas de calor y píxeles que nadie revisa.
3. Fuentes web limitadas a dos familias y con font-display: swap.
4. Caché en el servidor y un CDN delante.

En Next.js usa next/image y next/font, y deja como componentes de cliente solo las piezas interactivas. En WordPress, un plugin de caché, un tema liviano y menos plugins suelen resolver más que cualquier ajuste fino.

Auditoría en 10 minutos

Con cinco comandos de terminal revisas lo esencial: robots.txt, canonical, contenido en el HTML, schema y redirecciones. Hazlo en la home, en una página de servicio y en un artículo.

D=https://tudominio.com

# 1. ¿Qué ve el público en robots.txt?
curl -s $D/robots.txt

# 2. ¿El canonical apunta a la propia página?
curl -s $D/servicios | grep -o '<link rel="canonical"[^>]*>'

# 3. ¿El texto está en el HTML que reciben los bots?
curl -s -A "OAI-SearchBot" $D/servicios | grep -c "una frase de la página"

# 4. ¿Cuántos bloques de schema hay?
curl -s $D/servicios | grep -o 'application/ld+json' | wc -l

# 5. ¿Las variantes del dominio redirigen a una sola?
curl -sI http://tudominio.com | grep -i location
curl -sI https://www.tudominio.com | grep -i location

Si todo sale bien, pasa al capítulo 4, donde el trabajo se mueve de la infraestructura al contenido. Y si quieres llevar el control de todo esto, el checklist en PDF trae estos puntos listos para marcar.