Ghid llms.txt, robots.txt pentru AI

Ghid llms.txt:Ce este, cum funcționează și cine îl folosește de fapt

llms.txt este un fișier text în format Markdown, plasat la rădăcina domeniului (https://domeniu.ro/llms.txt), gândit ca hartă curată a site-ului pentru crawlerele AI — deși niciunul dintre marile motoare (Google, OpenAI, Anthropic, Perplexity) nu a confirmat public că îl citește: linkurile esențiale plus descrieri semantice scurte, fără HTML, scripturi sau balast vizual. Practic, echivalentul lui robots.txt pentru modele lingvistice, orientat însă spre ghidare, nu spre blocare.

De ce contează: într-un web dominat de asistenți conversaționali și motoare de căutare generative (AEO & GEO), roboții AI nu mai citesc paginile HTML așa cum o face Googlebot pentru a crea un index clasic de linkuri. Ei au nevoie de informație brută, pre-filtrată și structurată semantic pentru a oferi răspunsuri în timp real. Fără acest canal direct, site-ul tău devine invizibil pentru inteligența artificială sau, mai rău, este interpretat greșit, ducând la halucinații despre serviciile sau produsele tale.

Acest ghid acoperă strict execuția: specificațiile tehnice, codul complet de implementare pe WordPress, Shopify, Webflow și Next.js, plus regulile de validare pentru noii crawleri AI. Pentru dimensiunea strategică, cum folosești același fișier ca instrument de control al narativului despre brandul tău în răspunsurile AI, citește protocolul llms.txt de control narativ.

Ce este llms.txt și specificația sa tehnică

Fișierul llms.txt reprezintă o convenție comunitară (inițiată de Jeremy Howard în toamna anului 2024 și aflată în plină standardizare) care propune plasarea unui document text în format Markdown la rădăcina oricărui domeniu web: https://domeniu.ro/llms.txt.

Acest fișier funcționează ca o „hartă a site-ului” adaptată pentru LLM-uri: el elimină elementele vizuale grele, scripturile complexe și codul HTML inutil, servind exclusiv link-uri curate însoțite de o descriere semantică exactă de 1-2 propoziții per pagină.

Regulile de structurare sintactică

Conform specificațiilor standardizate de pe llmstxt.org, fișierul trebuie să respecte următoarea ierarhie Markdown strictă:

• Heading H1 (# Title): Reprezintă numele site-ului sau al secțiunii principale, urmat obligatoriu de o descriere generală a proiectului.
• Secțiunea de Sitemaps (## Sitemaps): Conține linkuri directe către sitemap-urile XML tradiționale pentru a permite crawlerului să identifice resursele secundare.
• Secțiuni tematice (## Section Title): Organizate de regulă în categorii precum Servicii, Articole, Produse sau Documentație.
• Liste de resurse: Fiecare pagină importantă din site trebuie să fie prezentată sub forma unui element de listă curat: [Titlu Pagină](URL) - Descriere semantică de maxim 150-200 de caractere.

De asemenea, standardul propune opțional un al doilea fișier extins, /llms-full.txt, care poate conține textele integrale ale tuturor articolelor și paginilor, concatenate și optimizate, pentru a permite asistenților AI să citească tot conținutul site-ului într-un singur apel de rețea (fără a efectua zeci de solicitări HTTP separate).

Ce spune Google (și ceilalți), de fapt — verificat la sursă

Aici e secțiunea pe care alte ghiduri nu ți-o dau, pentru că le strică pitch-ul. Înainte să investești un minut în llms.txt, trebuie să știi cine îl folosește cu adevărat. Am verificat la sursă, nu din memorie:

Cifra care închide discuția: un studiu Limy.AI↗ pe 500 de milioane de accesări de boți AI a găsit că doar 408 au țintit direct llms.txt — iar Ahrefs↗, pe 137.210 domenii, a găsit că 97% dintre fișiere nu primesc nicio cerere. Adoptarea, după 18 luni de discuții: sub 11%. Deci llms.txt nu e „larg adoptat" — e o convenție cu tracțiune mică și zero angajament oficial de la marile modele.

Cele trei lumi pe care nimeni nu le separă

1. Produsele de chat și căutare (ChatGPT answers, Perplexity, AI Overviews). Aici llms.txt e simbolic, cu mica excepție Perplexity. Ce te aduce în răspunsuri: să fii sursa cea mai clară și mai credibilă, indexabilă, curată.
2. Agenții de cod (Cursor, Claude Code). Aici llms.txt e util real — un dezvoltator îndreaptă agentul spre documentația unei librării, iar fișierul ajută ingestia. Dar n-are legătură cu „AI-ul care îți citează brandul".
3. Agentic browsing (Gemini Agent, agenții care navighează live). Agentul nu caută un fișier ascuns — deschide browserul și parcurge pagina randată în timp real, exact ca un om. Levierul erei agentice e pagina ta reală, curată, cu SSR, nu llms.txt.

Deci merită sau nu?

Da, dar pentru motivul corect. llms.txt e ieftin de generat și îl merită ca poliță pentru mica excepție Perplexity, pentru cazul agenților de cod, și ca pregătire dacă adoptarea crește. Beneficiile POSIBILE, pentru sistemele care ar ajunge să-l citească, sunt că tu scrii descrierile paginilor și o eventuală eficiență de crawl (un fișier Markdown se consumă într-un pas, fără DOM de construit sau scripturi de executat).

Ce NU e: nu e trucul pentru locul 1 în Google AI, nu te urcă în AI Overviews, nu e „larg adoptat". Dacă o agenție ți-l vinde ca mecanism principal, acum ai tabelul cu care s-o contrazici — cu surse.

Controlul real asupra a cine te antrenează și cine te citește se face în robots.txt, pe care toți boții AI îl respectă (GPTBot, ClaudeBot, PerplexityBot, Google-Extended) — nu în llms.txt.

Nu ne crede pe cuvânt:Măsoară singur

Focalizarea pe eficiența codului nu este un simplu trend de marketing, ci o decizie inginerească pe care o poți verifica direct, fără să te bazezi pe cifrele publicate de vreo agenție (inclusiv de noi):

• Testul de viteză: Rulează verdantmindset.com în PageSpeed Insights (pagespeed.web.dev). Apoi rulează, cu exact același instrument, site-ul agenției care îți promite viteză. Compară rezultatele una lângă alta — instrumentul e al Google, nu al nostru.
• Testul llms.txt: Deschide https://verdantmindset.com/llms.txt direct în browser. Vezi cu ochii tăi cum arată o hartă semantică servită ca text brut: linkuri curate, descrieri scurte, zero balast. Apoi încearcă același URL pe site-ul tău sau pe al furnizorului tău actual.

Acesta este standardul la care ar trebui să ții orice partener tehnic: afirmațiile de performanță se verifică cu instrumente publice, nu se acceptă din prezentări.

Ghid tehnic de implementare pe platforme CMS și Frameworks

Pentru ca fișierul llms.txt să își îndeplinească rolul, el nu trebuie doar să existe, ci trebuie generat automat și actualizat dinamic pentru a reflecta starea reală a site-ului tău. Iată codurile de implementare testate și optimizate pentru cele mai comune medii tehnice:

WordPress:Generare dinamică prin PHP (fără plugin-uri)

Dacă vrei să eviți instalarea unui plugin SEO greu și vrei control total asupra output-ului, poți adăuga următorul script în fișierul functions.php al temei tale child (sau într-un plugin custom de funcționalități):

<?php
// Activează o regulă custom de rescriere URL pentru llms.txt
add_action('init', 'vm_register_llms_rewrite');
function vm_register_llms_rewrite() {
    add_rewrite_rule('^llms\.txt$', 'index.php?vm_llms_trigger=1', 'top');
}

// Înregistrează variabila de query pentru declanșarea fișierului
add_filter('query_vars', 'vm_register_llms_query_vars');
function vm_register_llms_query_vars($vars) {
    $vars[] = 'vm_llms_trigger';
    return $vars;
}

// Interceptează cererea și livrează fișierul llms.txt în mod dinamic
add_action('template_redirect', 'vm_serve_llms_txt');
function vm_serve_llms_txt() {
    if (get_query_var('vm_llms_trigger')) {
        header('Content-Type: text/plain; charset=utf-8');
        header('Cache-Control: public, max-age=3600');
        
        echo "# " . get_bloginfo('name') . "\n\n";
        echo get_bloginfo('description') . "\n\n";
        
        echo "## Sitemaps\n";
        echo "- [" . __('Sitemap Principal', 'vm') . "](" . home_url('/sitemap_index.xml') . ")\n\n";
        
        // Preluare Pagini Importante
        $pages = get_pages(array('meta_key' => '_vm_include_llms', 'meta_value' => 'yes'));
        if (!empty($pages)) {
            echo "## Pagini Cheie\n";
            foreach ($pages as $page) {
                $desc = get_post_meta($page->ID, '_yoast_wpseo_metadesc', true);
                if (empty($desc)) {
                    $desc = wp_strip_all_tags(wp_trim_words($page->post_content, 20));
                }
                echo "- [" . $page->post_title . "](" . get_permalink($page->ID) . ") - " . esc_html($desc) . "\n";
            }
            echo "\n";
        }
        
        // Preluare Ultimele Articole din Blog
        $posts = get_posts(array('numberposts' => 100, 'post_status' => 'publish'));
        if (!empty($posts)) {
            echo "## Articole și Resurse\n";
            foreach ($posts as $post) {
                $desc = get_post_meta($post->ID, '_yoast_wpseo_metadesc', true);
                if (empty($desc)) {
                    $desc = wp_strip_all_tags(wp_trim_words($post->post_content, 20));
                }
                echo "- [" . $post->post_title . "](" . get_permalink($post->ID) . ") - " . esc_html($desc) . "\n";
            }
        }
        exit;
    }
}

Notă: După adăugarea acestui cod, accesează în panoul de administrare secțiunea Settings > Permalinks și apasă butonul Save Changes pentru a reseta regulile de rescriere ale WordPress.

Shopify:Generare dinamică prin Liquid Template

Deși Shopify are o structură mai rigidă a fișierelor statice la rădăcină, poți simula perfect un endpoint de text prin crearea unui șablon de tip pagină.

1. Creează un template nou în tema ta numit page.llms.liquid și adaugă următorul cod:

{% layout none %}
{%- header 'Content-Type: text/plain; charset=utf-8' -%}
# {{ shop.name }}

{{ shop.description }}

Sitemaps

• [Sitemap Shopify]({{ shop.url }}/sitemap.xml)

Products

{% for product in collections.all.products limit: 150 %}

• [{{ product.title }}]({{ shop.url }}{{ product.url }}) - {{ product.description | strip_html | strip_newlines | truncate: 160 }} {% endfor %}

Pages

{% for page in pages %}

• [{{ page.title }}]({{ shop.url }}{{ page.url }}) - {{ page.content | strip_html | strip_newlines | truncate: 160 }} {% endfor %}

2. Creează o pagină nouă în admin-ul Shopify cu titlul `llms` și asociază-i template-ul `page.llms`.
3. Pentru a direcționa calea `/llms.txt` către noua pagină, folosește secțiunea **Navigation > URL Redirects** din Shopify și setează o redirecționare de la `/llms.txt` la `/pages/llms`.

---

### 3. Next.js: Route Handler dinamic (`app/llms.txt/route.ts`)

În Next.js (App Router), implementarea unui dynamic API handler care să deservească conținut text pe o rută specifică este extrem de simplă și eficientă din punct de vedere computațional:

```typescript
import { NextResponse } from 'next/server';
import { getActiveBlogPosts, getCoreServices } from '@/lib/api';

export const revalidate = 3600; // Cachează rezultatul timp de o oră

export async function GET() {
  try {
    const posts = await getActiveBlogPosts();
    const services = await getCoreServices();
    
    let markdown = `# Verdant Mindset\n\n`;
    markdown += `Atelier de inginerie digitală, SEO tehnic și optimizare web sustenabilă.\n\n`;
    
    markdown += `## Sitemaps\n`;
    markdown += `- [Sitemap General](https://verdantmindset.com/sitemap.xml)\n\n`;
    
    markdown += `## Servicii Tehnice\n`;
    services.forEach((service) => {
      markdown += `- [${service.title}](https://verdantmindset.com/servicii/${service.slug}) - ${service.summary}\n`;
    });
    
    markdown += `\n## Articole și Ghiduri\n`;
    posts.forEach((post) => {
      markdown += `- [${post.title}](https://verdantmindset.com/resurse/${post.slug}) - ${post.description}\n`;
    });
    
    return new NextResponse(markdown, {
      status: 200,
      headers: {
        'Content-Type': 'text/plain; charset=utf-8',
        'Cache-Control': 'public, max-age=3600, s-maxage=3600',
      },
    });
  } catch (error) {
    return new NextResponse('Error generating llms.txt data', { status: 500 });
  }
}

Webflow:Proxy prin Cloudflare Workers

Deoarece Webflow nu permite crearea de fișiere arbitrare cu extensia .txt direct la rădăcina domeniului și nu suportă template-uri exclusiv text, cea mai curată metodă este configurarea unui proxy la nivel de DNS (Cloudflare Workers) care să deservească codul:

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const url = new URL(request.url)
  
  // Interceptează doar ruta /llms.txt
  if (url.pathname === '/llms.txt') {
    const llmsContent = `# Nume Proiect Webflow\n\n` +
      `Descriere tehnică a serviciilor companiei tale.\n\n` +
      `## Sitemaps\n` +
      `- [Sitemap](https://domeniu.ro/sitemap.xml)\n\n` +
      `## Servicii Cheie\n` +
      `- [Serviciu 1](https://domeniu.ro/serviciu-1) - Descriere detaliată.\n` +
      `- [Serviciu 2](https://domeniu.ro/serviciu-2) - Descriere detaliată.\n`;

    return new Response(llmsContent, {
      headers: { 
        'content-type': 'text/plain; charset=utf-8',
        'cache-control': 'public, max-age=86400'
      },
    })
  }
  
  // Permite ca toate celelalte cereri să meargă direct către serverele Webflow
  return fetch(request)
}

Cum se validează și se testează fișierul llms.txt

După implementare, este esențial să te asiguri că fișierul este configurat corect și poate fi consumat fără erori de crawlerele AI. Urmează acești pași de diagnosticare:

1. Verificarea antetului HTTP: Deschide terminalul și rulează o comandă curl -I https://domeniu.ro/llms.txt. Răspunsul trebuie să conțină neapărat Content-Type: text/plain; charset=utf-8. Dacă header-ul conține text/html, roboții AI vor refuza procesarea fișierului, considerându-l o eroare.
2. Validarea codării Markdown: Asigură-te că linkurile sunt scrise corect ([Titlu](URL)) și că nu există cod HTML rezidual injectat în interiorul descrierilor (de exemplu tags precum <p> sau &).
3. Testul de accesibilitate publică: Verifică dacă fișierul nu este blocat accidental prin reguli din robots.txt sau printr-un sistem de securitate de tip firewall / Cloudflare Challenge care cere interacțiune umană (JS challenge). Crawlerele AI trebuie să poată citi fișierul printr-o simplă cerere GET directă.