DEV Community: Juan Camilo Auriti

GEO Optimizer v4.0.0 is Stable — What We Fixed, What We Built, What's Next

Juan Camilo Auriti — Thu, 02 Apr 2026 14:10:09 +0000

v4.0.0 is out.

Not beta. Not release candidate. Stable.

This post is the honest story of how it got there: four beta releases, a full architectural rewrite, 13 security fixes, and a few new capabilities we are genuinely excited about.

pip install geo-optimizer-skill
# or upgrade from any previous version
pip install --upgrade geo-optimizer-skill

Why a Major Version?

GEO Optimizer started as a focused CLI tool in early 2025. By v3.x, the core audit engine — audit.py — had grown to 2270 lines. A single file handling HTTP fetching, scoring logic, content parsing, schema validation, bot detection, and output formatting. It worked. It was also increasingly difficult to test, extend, or reason about.

v4.0.0 fixes that, and along the way adds several new detection capabilities that the original architecture could not have supported cleanly.

Here is what changed.

Architecture: From Monolith to 12 Focused Modules

The 2270-line audit.py is gone. Its responsibilities now live in 12 separate modules, each with a single job:

Module	Responsibility
`audit.py`	Orchestration only — calls the others, assembles results
`citability.py`	42 citability signals (3200 lines, now properly isolated)
`scoring.py`	Score calculation, thresholds, grade assignment
`fixer.py`	Fix file generation (robots, llms, schema, meta, ai_discovery)
`injection_detector.py`	Prompt injection detection
`registry.py`	Plugin system via entry points

This matters for contributors. Before v4, adding a new audit check meant navigating a 2270-line file and hoping you did not break something adjacent. Now you add a module, register it via entry_points, and the plugin system handles the rest.

The public API is unchanged:

from geo_optimizer.core.audit import run_full_audit, run_full_audit_async

result = run_full_audit("https://yoursite.com")
print(result.score.total)   # same as before

13 Security Fixes

The beta cycle surfaced a cluster of security issues. All thirteen are patched in v4.0.0 stable.

The most important ones:

DNS Pinning — fetch_url() now validates the resolved IP against a block list before making the request. This prevents SSRF attacks where a user-supplied URL resolves to an internal network address (169.254.x.x, 10.x.x.x, 172.16-31.x.x, ::1, etc.). The check happens after DNS resolution, not before, so it handles DNS rebinding.

XSS Sanitization — The HTML report formatter now escapes all user-controlled content before rendering. Previously, a page title containing <script> would execute in the generated report.

SSRF Prevention — Every URL accepted from user input — CLI --url, API POST /api/audit, MCP tool arguments — goes through validators.resolve_and_validate_url() before any HTTP call is made. There is no code path that calls requests.get() directly on user input.

Auth Bypass — The /report/{id} endpoint now correctly enforces GEO_API_TOKEN when the token is set. Previously, it skipped authentication on the report retrieval endpoint even when the audit endpoint required it.

CSP Hardening — The web app now sets Content-Security-Policy, X-Content-Type-Options, X-Frame-Options, and Referrer-Policy headers on all responses.

If you are running the web demo in a semi-public context — internal tooling, shared staging, anything other than localhost — upgrading is not optional.

27 AI Bots (Was 24)

The tracked bot list grew from 24 to 27. Three additions: Applebot-Extended (Apple Intelligence), Kangaroo Bot (AI2 / Allen Institute), and Meta-ExternalFetcher (Meta AI).

The robots.txt audit checks for all 27. The fixer generates entries for all 27.

geo audit --url https://yoursite.com --format json | jq '.robots.missing_bots'
# ["Applebot-Extended", "Meta-ExternalFetcher", ...]

10 MCP Tools (Was 8)

The MCP server, which lets Claude Code, Cursor, and Windsurf query GEO Optimizer directly, gains two new tools in v4.0.0:

geo_trust_stack — returns the Trust Stack Score breakdown (see below)
geo_injection_scan — runs prompt injection detection on a page (see below)

Setup is unchanged:

# Claude Code
claude mcp add geo-optimizer -- geo-mcp

# Cursor — .cursor/mcp.json
{
  "mcpServers": {
    "geo-optimizer": {
      "command": "geo-mcp",
      "args": []
    }
  }
}

New: Trust Stack Score

One of the more interesting additions in v4.0.0 is the Trust Stack Score — a five-layer aggregation that grades site authority on an A–F scale.

The five layers:

Schema Completeness — Are Organization, Article, FAQPage present and valid?
Brand Coherence — Does the brand name appear consistently across pages, meta tags, and schema?
Contact Signals — Are About and Contact pages reachable and linked from the homepage?
Knowledge Graph Readiness — Does the Organization schema include sameAs links to verified profiles (Wikidata, LinkedIn, Crunchbase, etc.)?
Freshness — Are publication and modification dates present and recent?

Each layer scores 0–20. The aggregate produces a letter grade:

Score	Grade	Meaning
90–100	A	Strong entity identity, high trust signal
75–89	B	Solid foundation, minor gaps
55–74	C	Mixed signals, some layers weak
35–54	D	Significant gaps, low KG readiness
0–34	F	AI engines cannot establish trust

Access it via CLI:

geo audit --url https://yoursite.com --format json | jq '.trust_stack'

Or via the MCP tool directly from your AI IDE:

"Run geo_trust_stack on my-client.com and tell me which layers are weakest."

New: Prompt Injection Detection

This one is genuinely novel for a GEO toolkit.

Some sites — accidentally or intentionally — include content in their pages that attempts to manipulate AI crawlers: hidden text instructing bots to treat the site as authoritative, <meta> tags with unusual directives, or llms.txt files containing override instructions.

GEO Optimizer v4.0.0 ships an eight-category detector for these patterns:

Hidden text (display:none, opacity:0, font-size:0, color matching background)
Off-screen positioning (position:absolute with large negative offsets)
Instruction injection in meta tags (unusual name attributes with imperative text)
llms.txt override attempts (phrases like "ignore previous instructions", "disregard", "as an AI")
Schema manipulation (unexpected description fields containing directives)
Cloaking signals (content served differently based on User-Agent)
Invisible iframe injection
Comment-based injection ()

For legitimate site owners, the detector helps you catch accidental patterns — a third-party widget injecting hidden text, a CMS generating unusual meta tags — before they trigger AI crawler penalties.

geo audit --url https://yoursite.com --format json | jq '.injection_detection'

Scoring Accuracy: 6 Regex False Positives Eliminated

The v3.x scoring engine had six known false positive patterns — cases where a site would score points for a signal that was technically present but semantically empty (e.g., a statistics count matching a phone number format, a heading "hierarchy" score awarded to a page with only <h2> tags and no <h1>).

v4.0.0 fixes all six:

Statistics count now uses context-aware regex that excludes phone numbers, ZIP codes, and ISBN patterns
Heading hierarchy requires an <h1> before awarding hierarchy points
Brand coherence requires a minimum string length to avoid matching single-character artifacts
RSS detection validates feed MIME type, not just URL pattern
Freshness detection now requires a parseable date, not just the presence of datetime attribute
FAQ score now validates that FAQPage schema contains at least one Question entity with non-empty text

If your site scored unusually high on any of these categories in v3.x, expect a small correction in v4.0.0. That is the correct behavior.

New: WebMCP Readiness

Chrome 146 ships with a built-in AI agent capability (the "Web MCP" standard) that allows browser AI agents to interact with sites programmatically. GEO Optimizer v4.0.0 audits for compatibility with this emerging standard.

The check looks for:

A /.well-known/mcp.json manifest
A declared mcp-endpoint in HTTP headers or meta tags
Valid MCP capability declarations (tools, resources, prompts)

This is early days. Most sites score zero here because the standard is brand new. But as Chrome 146+ rolls out and AI agents become a real traffic source, having this in place ahead of the curve is the same bet as llms.txt was in early 2025.

Test Suite: 1120 Tests, 85% Coverage

The beta cycle added 90 tests beyond the 1030 in v3.x. All tests remain fully mocked — no real HTTP calls, no external dependencies.

pytest tests/ -v --cov=geo_optimizer
# 1120 passed, 0 failed
# coverage: 85%

The coverage target for v4.1.0 is 90%. The gap is mostly edge cases in the injection detector and schema validation paths.

Full English Codebase

Previous versions had a mix of Italian and English in code comments, docstrings, and error messages. v4.0.0 standardizes on English throughout the codebase — consistent with being an open-source project accepting contributions from a global audience.

The GEO_LANG environment variable still controls CLI output language (it or en). That is user-facing and unchanged.

Upgrading from v3.x

No breaking changes in the public API. The run_full_audit() and run_full_audit_async() function signatures are unchanged, and the result dataclasses are backward compatible.

The only thing to be aware of: the six scoring corrections above. If you have CI thresholds tuned against v3.x scores, run an audit on v4.0.0 before tightening those thresholds.

pip install --upgrade geo-optimizer-skill
geo audit --url https://yoursite.com

What's Next (v4.1.0)

The roadmap for v4.1.0 has three items:

Async batch audits — audit up to 50 URLs concurrently via geo audit --urls-file sites.txt
Historical tracking — geo audit will optionally write results to a local SQLite database, enabling trend charts via geo history
Playwright rendering mode — optional JS rendering pass for SPAs (opt-in, not default)

If any of these is a priority for your use case, open an issue and we will prioritize accordingly.

Try It

Web demo (no install):

geo-optimizer-web.onrender.com

CLI:

pip install geo-optimizer-skill
geo audit --url https://yoursite.com

GitHub (star if you find it useful):

github.com/Auriti-Labs/geo-optimizer-skill

Questions about a specific audit result or the new detection capabilities? Drop them in the comments — I read everything.

I Built a Python Tool to Check If AI Search Engines Can Find Your Website

Juan Camilo Auriti — Wed, 01 Apr 2026 08:31:13 +0000

You spent months tuning your <title> tags, chasing backlinks, submitting sitemaps to Google Search Console. Your rankings are solid. Then you ask ChatGPT about your industry — and it cites three of your competitors but not you.

You are not invisible to Google. You are invisible to the AI that is increasingly replacing Google.

This is the problem that Generative Engine Optimization (GEO) solves. And in this post, you will learn what GEO is, why it matters right now, and how to measure and fix your site's AI visibility using an open-source Python tool — in under 10 minutes.

SEO vs GEO: What's the Difference?

Traditional SEO optimizes for ranking: getting your blue link to appear on page one of Google's results. The signals are well understood — crawlability, backlinks, Core Web Vitals, structured data.

Generative Engine Optimization optimizes for citation: getting an AI model (ChatGPT, Perplexity, Claude, Gemini) to mention, quote, or link to your content when a user asks a relevant question. These models do not return a list of ten blue links. They synthesize an answer — and if your site is not part of that synthesis, you simply do not exist in that response.

The signals are fundamentally different:

Signal	SEO	GEO
Primary goal	Rank high in SERPs	Be cited in AI answers
Crawler	Googlebot	GPTBot, ClaudeBot, PerplexityBot...
Key file	`sitemap.xml`	`llms.txt`
Schema priority	Breadcrumbs, Products	FAQPage, Article, Organization
Content style	Keyword density	Factual claims, statistics, citations
Trust signal	Backlinks	Authorship, dates, authoritative quotes

The research backing this comes from Princeton KDD 2024 and AutoGEO ICLR 2026 — peer-reviewed work showing that specific content and technical signals consistently increase a site's citation rate in large language model responses.

Meet GEO Optimizer

GEO Optimizer is an open-source Python toolkit (MIT license) that audits your website across all eight GEO signal categories, gives you a 0–100 score, and generates the files you need to fix the gaps.

1030 tests, zero external HTTP calls in the test suite
Based on Princeton KDD 2024 + AutoGEO ICLR 2026 research
Four CLI commands: geo audit, geo fix, geo llms, geo schema
MCP server for AI-powered IDE integration (Claude Code, Cursor, Windsurf)
Web demo at geo-optimizer-web.onrender.com
Current version: v4.0.0-beta.1

Installation

Requires Python 3.9+.

pip install geo-optimizer-skill

That is the entire installation. Verify it worked:

geo --version
# geo-optimizer-skill 4.0.0b1

Your First Audit

geo audit --url https://yoursite.com

The tool fetches your homepage, robots.txt, llms.txt, checks for JSON-LD schema blocks, meta tags, content quality signals, and AI discovery endpoints. The whole thing runs in a few seconds.

A typical output looks like this:

 GEO Optimizer — AI Citability Audit
 https://yoursite.com

 ROBOTS.TXT ─────────────────────────────────────────────────
   GPTBot           MISSING  (OpenAI — ChatGPT training)   critical
   OAI-SearchBot    MISSING  (OpenAI — ChatGPT citations)  critical
   ClaudeBot        allowed
   PerplexityBot    MISSING                                 critical

 LLMS.TXT ────────────────────────────────────────────────────
   Not found at https://yoursite.com/llms.txt

 SCHEMA JSON-LD ──────────────────────────────────────────────
   WebSite schema   found
   FAQPage schema   missing
   Article schema   missing
   Organization     missing

 META TAGS ───────────────────────────────────────────────────
   Title            yoursite.com - Home
   Description      missing
   Canonical        found
   OG tags          found

 CONTENT QUALITY ─────────────────────────────────────────────
   Headings         8
   Statistics       0        add numbers + data
   External links   0        add authoritative citations

 AI DISCOVERY ────────────────────────────────────────────────
   /.well-known/ai.txt        missing
   /ai/summary.json           missing

──────────────────────────────────────────────────────────────
 GEO SCORE   [████████░░░░░░░░░░░░]   41 / 100   FOUNDATION
──────────────────────────────────────────────────────────────

 Top recommendations:
   1. Add all 24 AI bots to robots.txt (currently blocking ChatGPT)
   2. Create llms.txt — biggest single GEO win available
   3. Add FAQPage schema for AI answer extraction
   4. Add statistics and data references to content

Score bands:

Score	Band	What it means
86–100	Excellent	Optimized for AI citation
68–85	Good	Solid foundation, tune for specifics
36–67	Foundation	Gaps exist, AI crawlers partially blocked
0–35	Critical	Invisible or blocked from most AI engines

The 8 Audit Categories Explained

GEO Optimizer evaluates eight signal areas, each weighted based on their empirical impact on AI citation rates.

1. Robots.txt (18 points)

What it checks: Whether the 24 known AI crawlers are explicitly allowed in your robots.txt. Many sites have a blanket User-agent: * rule that technically allows everything — but missing explicit entries for bots like GPTBot, OAI-SearchBot, PerplexityBot, and ClaudeBot can mean those bots apply conservative defaults.

Why it matters: If a bot cannot crawl your site, it cannot index or cite it. This is the single fastest fix available — it takes five minutes and affects everything downstream.

2. llms.txt (18 points)

What it checks: Whether your site has an /llms.txt file, and whether that file includes a proper H1, blockquote description, structured sections, links to key pages, and a full-text variant (/llms-full.txt).

Why it matters: llms.txt is an emerging standard (proposed 2024) that gives AI models a curated, machine-readable summary of your site. It is the sitemap.xml of the GEO era. Sites with a well-formed llms.txt see measurably higher citation rates in Perplexity and other retrieval-augmented systems.

3. JSON-LD Schema (16 points)

What it checks: Presence and quality of structured data — specifically WebSite, Organization, FAQPage, and Article schema types.

Why it matters: FAQPage schema is directly extracted by AI systems to populate answer snippets. Article schema provides authorship and date signals that LLMs use to assess freshness and trustworthiness.

4. Meta Tags (14 points)

What it checks: Title tag quality, meta description, canonical URL, and Open Graph tags.

Why it matters: Meta descriptions and OG descriptions are often used verbatim by AI systems when summarizing a page. A missing description means the AI has to guess — and it usually gets it wrong or omits your site.

5. Content Quality (12 points)

What it checks: Heading hierarchy (h1 through h3), presence of statistics and numeric claims, front-loaded key information, use of lists, word count, and external citation links.

Why it matters: Princeton GEO research found that content with verifiable statistics and authoritative citations is cited 2–3x more frequently than equivalent content without them. "Cite your sources" turns out to be good advice for getting cited yourself.

6. Signals (6 points)

What it checks: lang attribute on <html>, RSS/Atom feed presence, and content freshness indicators (structured date data or visible publication dates).

Why it matters: AI systems use language declarations to route queries correctly. RSS feeds allow AI-integrated news systems to track your content. Date signals affect how AI systems rank freshness for time-sensitive queries.

7. AI Discovery Endpoints (6 points)

What it checks: Whether your site exposes /.well-known/ai.txt, /ai/summary.json, /ai/faq.json, and /ai/service.json.

Why it matters: These endpoints let AI crawlers self-serve a structured overview of your site without parsing full HTML. They are the API layer for AI discovery.

8. Brand and Entity (10 points)

What it checks: Coherence of brand name across pages, knowledge graph readiness, presence of About and Contact pages, geographic identity signals, and topic authority clustering.

Why it matters: LLMs build entity graphs. A site with a clear, consistent entity identity (one brand name, one headquarters, one topical focus) is significantly more likely to be cited as an authoritative source than a site with scattered signals.

Auto-Fix: Generate the Missing Files

Auditing is the diagnosis. geo fix is the treatment:

geo fix --url https://yoursite.com

This generates ready-to-deploy files:

A robots.txt patch with all 24 AI bots explicitly allowed
A complete llms.txt built from your sitemap
Missing JSON-LD schema blocks as <script> snippets
Meta tag HTML for any missing tags

You can also target a specific category:

geo fix --url https://yoursite.com --only llms
geo fix --url https://yoursite.com --only schema

And generate just the llms.txt separately:

geo llms --url https://yoursite.com

Python API Usage

If you need to integrate GEO auditing into your own tooling, the Python API is clean and returns typed dataclasses — it never prints to stdout.

from geo_optimizer.core.audit import run_full_audit

result = run_full_audit("https://yoursite.com")

print(result.score)          # 41
print(result.band)           # "foundation"
print(result.robots.score)   # 8
print(result.llms.score)     # 0

for rec in result.recommendations:
    print(f"- {rec}")
# - Add all 24 AI bots to robots.txt
# - Create llms.txt
# - Add FAQPage schema

For async contexts (FastAPI, async scripts):

import asyncio
from geo_optimizer.core.audit import run_full_audit_async

async def check_site(url: str) -> dict:
    result = await run_full_audit_async(url)
    return {
        "score": result.score,
        "band": result.band,
        "top_issues": result.recommendations[:3],
    }

asyncio.run(check_site("https://yoursite.com"))

The JSON output format works well for dashboards and monitoring pipelines:

geo audit --url https://yoursite.com --format json | jq '.score'

CI/CD Integration: Catch Regressions Before They Ship

One of the most practical use cases is automated GEO regression testing. A CMS update can silently break your schema. A robots.txt change can accidentally block AI bots. Catching this in CI costs nothing.

The easiest path is the official GitHub Action:

# .github/workflows/geo-audit.yml
name: GEO Audit

on:
  push:
    branches: [main]
  pull_request:

jobs:
  geo:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: Auriti-Labs/geo-optimizer-skill@v1
        with:
          url: https://yoursite.com
          threshold: 68        # Fail if score drops below "good" band
          format: sarif        # Appears in GitHub Security tab

With format: sarif, findings automatically populate the Security tab of your repository as Code Scanning alerts — no extra configuration needed.

For PR comments that show the score on every pull request:

- uses: Auriti-Labs/geo-optimizer-skill@v1
  id: geo
  with:
    url: https://yoursite.com

- uses: actions/github-script@v7
  if: github.event_name == 'pull_request'
  with:
    script: |
      const score = '${{ steps.geo.outputs.score }}';
      const band  = '${{ steps.geo.outputs.band }}';
      await github.rest.issues.createComment({
        owner: context.repo.owner,
        repo:  context.repo.repo,
        issue_number: context.issue.number,
        body: `## GEO Audit\n\n**Score:** ${score}/100  **Band:** \`${band}\``
      });

For teams using JUnit-compatible CI dashboards (Jenkins, CircleCI, etc.):

- uses: Auriti-Labs/geo-optimizer-skill@v1
  with:
    url: https://yoursite.com
    format: junit
    output-file: geo-results

- uses: dorny/test-reporter@v1
  with:
    name: GEO Audit
    path: geo-results.xml
    reporter: java-junit

MCP Server: GEO Audits Inside Your AI IDE

If you use Claude Code, Cursor, or Windsurf, you can install the GEO Optimizer MCP server and audit sites directly from your AI assistant without leaving the editor.

pip install geo-optimizer-skill[mcp]

Claude Code setup:

claude mcp add geo-optimizer -- geo-mcp

Cursor setup — add to .cursor/mcp.json:

{
  "mcpServers": {
    "geo-optimizer": {
      "command": "geo-mcp",
      "args": []
    }
  }
}

Once connected, you can ask your AI assistant things like:

"Run a GEO audit on my-client-site.com and list the top three issues."

"Generate an llms.txt for https://docs.myproduct.com"

"Validate the JSON-LD schema on the homepage"

The MCP server exposes eight tools: geo_audit, geo_fix, geo_llms_generate, geo_schema_validate, geo_citability, geo_ai_discovery, geo_trust_score, and geo_compare. The last one is particularly useful for competitive analysis — you can compare your GEO score against a competitor's in a single call.

Try It Now

The fastest way to see where you stand is the web demo — no installation required:

geo-optimizer-web.onrender.com

Paste your URL, get a full breakdown in seconds.

If you want the CLI:

pip install geo-optimizer-skill
geo audit --url https://yoursite.com

Key Takeaways

GEO is not SEO. Ranking on Google and being cited by ChatGPT require different signals. Both matter in 2026.
The biggest wins are quick. Fixing robots.txt to allow AI bots and adding llms.txt can be done in under an hour and covers 36 of the 100 available points.
Automate the regression check. One GitHub Actions step catches GEO regressions the same way ESLint catches code quality issues — before they reach production.
The MCP server brings auditing into your editor. If you are already using an AI IDE, you can add GEO checks to your development workflow with a single command.

Resources

GitHub: github.com/Auriti-Labs/geo-optimizer-skill — star the repo to follow updates
Web demo: geo-optimizer-web.onrender.com — free, no account required
Documentation: auriti-labs.github.io/geo-optimizer-skill
Princeton KDD 2024 paper: GEO: Generative Engine Optimization
llms.txt standard: llmstxt.org

If the tool helps you, a GitHub star helps more developers find it. If you find a bug or want to contribute a new audit check, pull requests are open and the contributing guide is in the repo.

What AI search visibility issues have you run into? Drop them in the comments — I read everything.

Your site ranks #1 on Google but AI never cites it. Here's how to fix it (open source tool)

Juan Camilo Auriti — Mon, 16 Mar 2026 16:10:40 +0000

GEO (Generative Engine Optimization) is the new discipline that makes your site visible to ChatGPT, Perplexity, Claude, and Gemini. I built an open source Python toolkit to audit and fix it in 15 minutes

You worked hard to get that first page ranking on Google.

But the other day, someone asked ChatGPT about your niche — and your competitor got cited. Not you.

That's not a coincidence. That's a structural problem, and it has a name: your site isn't optimized for AI search engines.

This post explains why, what GEO (Generative Engine Optimization) actually is, and how I built an open source Python tool — geo-optimizer-skill — to audit and fix it in about 15 minutes.

The problem nobody is talking about

AI search engines don't work like Google. They don't give you a list of ten blue links. They give a direct answer and cite their sources inline.

User: "What's the best way to calculate compound interest?"

Perplexity: "According to [Competitor.com], the standard formula is..."
                        ↑ They appear. You don't.

This means two sites can cover the exact same topic at the same quality level — but only one gets cited, consistently. The difference isn't content quality. It's structural optimization.

If your site isn't telling AI bots what it's about, in the format they understand, you're invisible. Even if you rank #1 on Google.

What is GEO?

GEO (Generative Engine Optimization) is the practice of optimizing web content to be cited by AI-powered search engines — not just crawled and ranked by traditional algorithms.

The term comes from a 2024 research paper by Princeton University (published at KDD 2024), which ran over 10,000 real queries against Perplexity.ai and measured which content optimization techniques actually increased citation frequency.

The results were striking:

| Method | Visibility increase |

|--------|-------------------|
| Cite authoritative sources | up to +115% |
| Add statistics and data | +40% average |
| Fluency optimization | +15–30% |
| Keyword stuffing | ~0% (ineffective) |

The paper is here if you want to read it: arxiv.org/abs/2311.09735

These aren't SEO myths. This is empirical data from controlled experiments on a live AI search engine.

Why I built this tool

I've been a full-stack developer for 15 years, mostly working on web projects for private clients — e-commerce, SaaS, content sites.

About a year ago I started noticing a pattern: clients were asking "why doesn't our site appear in ChatGPT answers?". At first I brushed it off. Then I started digging into the Princeton research, and realized this was a real, fixable, technical problem.

The issue was that there was no reliable way to audit a site for GEO compliance. SEO tools didn't check for it. No CLI existed. You had to manually go through a checklist.

So I built geo-optimizer-skill — a Python toolkit that:

Audits any site and gives it a GEO score from 0 to 100
Generates the /llms.txt file AI engines use to understand your site
Generates and injects JSON-LD structured data (WebSite, FAQPage, WebApplication)

What the tool checks

The audit covers 5 categories, each with a weighted score:

1. robots.txt — AI Bot Access (20 pts)
Are the major AI crawlers allowed? GPTBot, ClaudeBot, PerplexityBot, Google-Extended, OAI-SearchBot... The tool checks all 13 critical bots and tells you exactly which ones are missing.

2. /llms.txt — The AI index file (20 pts)
This is a machine-readable file at your site's root that tells AI engines what your site is about, how it's structured, and which pages matter. Think of it as a sitemap designed for LLMs. The tool checks if it exists, if it's properly structured, and if it has enough content.

3. JSON-LD Schema (25 pts)
Structured data is how you tell AI engines your content type, author, topic, and relationships. The tool checks for WebSite, WebApplication, and FAQPage schemas — the three most impactful for AI citation.

4. Meta tags (20 pts)
Title, description, canonical, Open Graph. These affect how AI engines parse and excerpt your content.

5. Content quality (15 pts)
Heading structure, presence of statistics, external citations, word count. Directly mapped to Princeton GEO methods.

Quick start

Install with pip:

pip install geo-optimizer-skill

Run an audit on any public URL:

geo audit --url https://yoursite.com

Here's what the output looks like:

============================================================
  1. ROBOTS.TXT — AI Bot Access
============================================================
  ✅ GPTBot allowed ✓
  ✅ ClaudeBot allowed ✓
  ✅ PerplexityBot allowed ✓
  ⚠️  meta-externalagent not configured (Meta AI)

============================================================
  2. LLMS.TXT — AI Index File
============================================================
  ✅ llms.txt found (200, 6517 bytes)
  ✅ H1 present, blockquote description present
  ✅ 6 H2 sections, 46 links to site pages

============================================================
  3. SCHEMA JSON-LD — Structured Data
============================================================
  ✅ Found 2 JSON-LD blocks
  ✅ WebSite schema ✓
  ⚠️  FAQPage schema missing

============================================================
  5. CONTENT QUALITY — GEO Best Practices
============================================================
  ✅ Good heading structure: 31 headings (H1–H4)
  ✅ Numerical data present: 15 numbers/statistics ✓
  ⚠️  No external source links detected

============================================================
  📊 FINAL GEO SCORE
============================================================

  [█████████████████░░░] 85/100
  ✅ GOOD — Core optimizations in place, fine-tune content and schema

  📋 NEXT PRIORITY STEPS:
  1. Add FAQPage schema with frequently asked questions
  2. Cite authoritative sources with external links

Clear, actionable, no guessing.

Generate your /llms.txt automatically

If your site has a sitemap, the tool can auto-generate a properly structured /llms.txt file:

geo llms \
  --base-url https://yoursite.com \
  --site-name "MySite" \
  --description "Short description of what your site does" \
  --output ./public/llms.txt

It auto-detects your sitemap, groups URLs by category, and produces a structured Markdown file that follows the llmstxt.org spec.

Generate and inject JSON-LD schema

# Analyze an existing HTML file
geo schema --file index.html --analyze

# Generate a WebSite schema
geo schema --type website --name "MySite" --url https://yoursite.com

# Inject FAQPage schema directly into a file
geo schema --file page.html --type faq --inject

# Generate snippet for Astro BaseLayout
geo schema --astro --name "MySite" --url https://yoursite.com

Supported schema types: website, webapp, faq, article, organization, breadcrumb.

CI/CD integration

The audit supports JSON output, so you can gate deployments on your GEO score:

geo audit --url https://yoursite.com --format json --output report.json

SCORE=$(jq '.score' report.json)
if [ "$SCORE" -lt 70 ]; then
  echo "GEO score too low: $SCORE/100"
  exit 1
fi

A GEO regression check in your pipeline. Same concept as a Lighthouse performance budget.

The 9 Princeton GEO methods

Based on the research paper, these are the techniques that actually move the needle on AI citation rates, in priority order:

Priority	Method	Measured impact
🔴 1	Cite authoritative sources — link to external sources with credibility	+30–115%
🔴 2	Add statistics — specific numbers, percentages, dates, measurements	+40%
🟠 3	Quote experts — direct quotes with attribution	+30–40%
🟠 4	Authoritative tone — precise, expert language	+6–12%
🟡 5	Fluency optimization — clear sentences, logical flow	+15–30%
🟡 6	Accessibility — define terms, use analogies	+8–15%
🟢 7	Technical terms — correct industry terminology	+5–10%
🟢 8	Vocabulary variety — avoid repetition	+5–8%
❌ 9	Keyword stuffing — proven ineffective for GEO	~0%

Notice what's at the bottom: keyword density. The technique that still dominates a lot of SEO thinking has zero measurable impact on AI citation. Meanwhile, citing sources — something many sites skip — can more than double your visibility.

GEO checklist before publishing any page

☐ robots.txt — all major AI bots have Allow: /
☐ /llms.txt — present at site root, structured, updated
☐ WebSite schema — in global <head> on all pages
☐ WebApplication schema — on every tool or product page
☐ FAQPage schema — on every page with Q&A content
☐ At least 3 external citations to authoritative sources
☐ At least 5 concrete numerical data points
☐ Meta description — accurate, 120–160 chars
☐ Canonical URL — on every page
☐ Open Graph tags — og:title, og:description, og:image

This checklist is also included in the repo as part of the AI context files.

Use it with your AI coding assistant

The repo includes context files for every major AI coding platform:

Platform	File
Claude Projects	`ai-context/claude-project.md`
ChatGPT Custom GPT	`ai-context/chatgpt-custom-gpt.md`
Cursor	`ai-context/cursor.mdc`
Windsurf	`ai-context/windsurf.md`
Kiro	`ai-context/kiro-steering.md`

Once loaded in your assistant, you can just say: "audit my site" or "generate the llms.txt for this sitemap" and it knows exactly what to do.

What's inside the repo

geo-optimizer/
├── 📄 SKILL.md                     ← Index of AI context files
├── 🧠 ai-context/                  ← Platform-specific context files
├── 🐍 scripts/
│   ├── geo_audit.py                ← Score 0–100, find what's missing
│   ├── generate_llms_txt.py        ← Auto-generate /llms.txt
│   └── schema_injector.py          ← Generate & inject JSON-LD
├── 📚 references/
│   ├── princeton-geo-methods.md    ← The 9 research-backed methods
│   ├── ai-bots-list.md             ← 25+ AI crawlers robots.txt block
│   └── schema-templates.md         ← 8 JSON-LD templates
└── 📁 docs/                        ← Full documentation (9 pages)

800+ tests, MIT license, security-hardened (SSRF prevention, XSS protection, path traversal validation).

The bigger picture

Traditional SEO optimizes for ranking. You try to be relevant to a query so a crawler surfaces you in a list.

GEO optimizes for citation. You try to be the source an AI chooses when constructing an answer. The signal isn't position — it's trust, structure, and explicit authority.

These are different games with different rules. The good news is that GEO-optimized content also tends to be better SEO content: it's more structured, better cited, and more precise. Fixing one often improves the other.

The bad news is that most sites are starting from zero on GEO. The robots.txt is missing critical bots. There's no /llms.txt. The JSON-LD covers only WebSite and nothing else. The content has no external citations.

That's fixable. It just needs a tool.

Try it

pip install geo-optimizer-skill
geo audit --url https://yoursite.com

GitHub: github.com/Auriti-Labs/geo-optimizer-skill

If you run an audit on your site, I'd love to hear what score you get and what the biggest gaps were. Drop it in the comments.

And if this saved you time — a ⭐ on GitHub helps others find it.

Built by Juan Camilo Auriti — full-stack developer and creator of Auriti Labs. Based on Princeton KDD 2024 research.

Triage-Relay

Juan Camilo Auriti — Fri, 27 Feb 2026 17:22:45 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

Open-source maintainers — the people who keep the software world running, mostly for free.

If you maintain a popular repo, you know the pattern: issues pile up faster than you can read them. Many are duplicates, some need more info, a few are critical bugs buried under noise. Contributors want to help, but giving push access to strangers is a non-starter.

The result? Burnout. Stale backlogs. Good issues lost in the flood.

Triage Relay exists because triage should be a team sport, not a solo burden.

What I Built

Triage Relay is a collaborative issue triage platform for GitHub repositories. It lets community volunteers help maintainers manage their backlog — without needing any dangerous permissions.

The core idea is simple: propose, don't push.

Here's how it works:

Connect — A maintainer links their GitHub repo and creates a triage room
Triage — Volunteers browse open issues, generate AI-powered briefs, and propose actions (add a label, post a comment, flag a duplicate)
Apply — The maintainer reviews proposals in their inbox and applies them to GitHub with one click

The key innovation is the proposal layer. Triagers never touch the repo directly. They suggest; maintainers decide. This makes it safe to open triage to your entire community.

AI Briefs

When a triager opens an issue, they can generate an AI brief that includes:

A concise summary of the issue
Suggested labels based on the repo's label set
Potential duplicates detected against existing issues
Missing information that should be requested
A draft comment ready to be refined
A confidence score and recommended action

The AI does the heavy lifting. Humans make the calls.

Demo

Live app: triage-relay.vercel.app

Log in with GitHub, create a room for any public repo, and start triaging. Try it with a busy repo like facebook/react or vercel/next.js to see the AI briefs in action.

Code

auriti / triage-relay

Collaborative issue triage for open-source maintainers. AI-powered briefs, proposals, and one-click apply. Built for the DEV Weekend Challenge.

Triage Relay

Collaborative issue triage for open-source maintainers.

Triage Relay turns your GitHub backlog into a decision queue. Community volunteers analyze issues, generate AI-powered briefs, and propose actions — maintainers review and apply with one click. No push access required.

Live Demo · DEV Challenge Submission

How It Works

Volunteer opens issue → Generates AI brief → Proposes action
                                                    ↓
Maintainer reviews proposal → One click → Applied on GitHub

Connect — Link any GitHub repository and create a triage room
Triage — Volunteers browse issues, generate AI briefs, and submit proposals (label, comment, flag duplicate, request info)
Apply — Maintainers review proposals and push them to GitHub instantly

The core principle: propose, don't push. Triagers never touch the repo directly.

AI Briefs

Each issue can be analyzed by AI to produce a structured brief:

Concise summary of the issue
Suggested labels from the repo's label set
Potential duplicates…

View on GitHub

How I Built It

Stack

Layer	Technology
Framework	Next.js 16 (App Router, React 19, Turbopack)
Language	TypeScript (strict mode)
Styling	Tailwind CSS v4 + shadcn/ui
Database & Auth	Supabase (Postgres + GitHub OAuth)
AI	Groq (Llama 3.3 70B with strict JSON schema)
GitHub API	Octokit REST
Deploy	Vercel (free tier)

Architecture highlights

Auth flow — GitHub OAuth through Supabase captures the provider_token in the callback and stores it as an httpOnly cookie. This token powers all GitHub API calls. Supabase doesn't persist it after login, so catching it at the right moment was critical.

AI briefs — Groq's json_schema mode with strict: true guarantees structured output every time. The prompt includes the repo's label set and the last 50 issue titles for duplicate detection. Response time is consistently under 2 seconds.

Proposal system — Proposals are typed as a discriminated union (label | comment | duplicate | needs_info), each with its own payload shape. When a maintainer approves, the API route reads the payload and maps it to the right GitHub API call — addLabel(), addComment(), or both.

Row Level Security — Every table has RLS policies. Maintainers can do everything in their rooms. Triagers can read issues and create proposals, but can't modify them after submission. Server-side operations use a service role client to bypass RLS for cache management.

Issue sync — Paginated fetch (5 pages × 100 items), filters out pull requests (GitHub's issues endpoint returns both), caches in Supabase with a 5-minute cooldown to respect rate limits.

What I'd add with more time

Real-time updates via Supabase Realtime
Batch proposal review (approve/reject multiple at once)
Activity feed showing recent triage actions
GitHub webhook integration for instant sync
Triager reputation system based on approval rate

I Built a Memory System That Thinks Like a Human Brain - Here's How Kore Memory Works

Juan Camilo Auriti — Fri, 27 Feb 2026 07:59:05 +0000

The Problem: AI Agents Have Amnesia

Every conversation with an AI agent feels like meeting them for the first time. They don't remember what you told them yesterday. They don't learn from interactions. Every session is a blank slate.

Current "memory solutions" are worse than useless:

Mem0, Zep, Letta require cloud APIs (privacy nightmare)
They call LLMs just to decide what's worth storing (expensive, slow, dependency hell)
They remember everything forever in a flat database (useless bloat)
They cost money per request

What if memory worked like a human brain instead? Remembering what matters. Forgetting what doesn't. Automatically. Offline.

That's Kore Memory.

What is Kore Memory? (30-Second Pitch)

Kore Memory is a persistent memory layer for AI agents built on three principles:

100% Offline — Runs on SQLite. No cloud. No LLM calls. No API keys to cloud services. Ship it with your agent.
Forgets Like Humans — Implements the Ebbinghaus forgetting curve. Critical memories stick around for months. Casual notes fade in days. Each retrieval extends the half-life.
Zero LLM Overhead — Auto-scores importance using keyword analysis and category signals. No OpenAI calls. No latency tax.

Install it:

pip install kore-memory[semantic]
kore
# → http://localhost:8765

That's it. You now have persistent, intelligent memory for your agent.

The Science: Ebbinghaus Forgetting Curve

You probably learned about the Ebbinghaus forgetting curve in school. After you learn something, you forget it exponentially fast unless you review it.

Kore implements this mathematically:

decay_score = e^(-t · ln2 / half_life)

Where:

t = days since memory was created (or last accessed)
half_life = days until the memory is 50% "forgotten"

The half-life scales with importance:

Importance	Label	Half-life
1	Low	7 days
2	Normal	14 days
3	Important	30 days
4	High	90 days
5	Critical	365 days

Here's the clever part: every time you retrieve a memory, its decay score jumps up by 0.05 (capped at 1.0) and the effective half-life extends by 15% — exactly like spaced repetition in human learning. Your brain strengthens pathways you use frequently.

Memories below decay_score 0.05 are "forgotten" — filtered from all searches. They're still in the database (soft delete), but your agent won't accidentally retrieve stale info.

Auto-Importance Scoring (Zero LLM Cost)

Most memory systems ask "is this important?" and wait for an LLM response. Not Kore.

Kore scores importance locally using three signals, no AI needed:

1. Category Baseline

preference → 4 (user preferences matter)
decision   → 4 (architectural choices matter)
project    → 3 (project context is valuable)
task       → 2 (one-off tasks are ephemeral)
general    → 1 (random notes are low value)

2. Keyword Analysis

"password", "token", "secret", "api_key" → +1 (add 1 to importance)
"prefers", "likes", "dislikes" → +0 (preference signals already baseline 4)
"critical", "urgent", "never" → +1
"remember", "important" → +1

3. Length Bonus

60+ words → +1 (longer = more context = probably important)

Concrete examples:

kore.save("API token: sk-abc123def456")
# → importance: 5 (token keyword pushes baseline 1 → 5)

kore.save("Juan prefers dark mode and concise responses")
# → importance: 4 (preference baseline + length bonus)

kore.save("Meeting at 3pm")
# → importance: 1 (short, generic)

kore.save("CRITICAL: Always sanitize user input")
# → importance: 5 (decision baseline 4 + critical keyword)

No API calls. No network roundtrips. Instant, local, deterministic.

Code Examples: Getting Started

Quick Start (3 Lines)

pip install kore-memory[semantic]
kore
# → Kore running on http://localhost:8765
# → Dashboard: http://localhost:8765/dashboard

Open your browser. You now have a web UI to save, search, and manage memories. Dark theme. No build step. No frontend framework. Pure HTML/CSS/JS inline in Python.

Python SDK: Save & Search

from kore_memory import KoreClient

# Sync client
with KoreClient("http://localhost:8765", agent_id="my-agent") as kore:
    # Save a memory
    memory = kore.save(
        content="User prefers dark mode and concise technical responses",
        category="preference"
    )
    print(f"Saved with importance: {memory.importance}")  # → 4

    # Search semantically
    results = kore.search(
        q="dark theme preference",
        semantic=True,
        limit=5
    )
    for mem in results.results:
        print(f"Score: {mem.decay_score:.2f} | {mem.content}")

    # Add tags
    kore.add_tags(memory.id, ["ui", "user-prefs"])

    # Search by tag
    ui_memories = kore.search_by_tag("ui")

JavaScript/TypeScript SDK

import { KoreClient } from 'kore-memory-client';

const kore = new KoreClient({
  baseUrl: 'http://localhost:8765',
  agentId: 'my-agent'
});

// Save
const result = await kore.save({
  content: 'React 19 supports server components',
  category: 'project',
  importance: 3
});

// Search
const memories = await kore.search({
  q: 'server components',
  semantic: true,
  limit: 5
});

// Relations (build a knowledge graph)
await kore.addRelation(result.id, otherId, 'depends_on');

LangChain Integration

from langchain.chains import LLMChain
from kore_memory.integrations import KoreLangChainMemory

# 5 lines to add persistent memory to any LangChain chain
memory = KoreLangChainMemory(
    kore_url="http://localhost:8765",
    agent_id="langchain-agent"
)

chain = LLMChain(llm=model, memory=memory, prompt=prompt)
response = chain.invoke({"question": "What's my favorite language?"})
# → Memory automatically saves the exchange

The KoreLangChainMemory class extends LangChain's BaseMemory. It auto-saves exchanges with semantic context. Next conversation, the agent remembers.

CrewAI Integration

from crewai import Agent
from kore_memory.integrations import KoreCrewAIMemory

# Split short-term (ephemeral) and long-term (persistent) memory
short_term = KoreCrewAIMemory(
    kore_url="http://localhost:8765",
    agent_id="crew-agent",
    ttl_hours=24  # Expires after 24 hours
)

long_term = KoreCrewAIMemory(
    kore_url="http://localhost:8765",
    agent_id="crew-agent"
    # No TTL = persists forever (or until decay filters it)
)

agent = Agent(
    name="researcher",
    memory=long_term,  # or short_term, or mix both
    tools=[...]
)

MCP Integration (Claude Desktop)

Kore ships with a Model Context Protocol server. Plug it directly into Claude Desktop:

pip install kore-memory[mcp]
kore-mcp  # Start the MCP server

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "kore-memory": {
      "command": "kore-mcp",
      "args": []
    }
  }
}

Now Claude has 14 memory tools:

memory_save — Save with auto-scoring
memory_search — Semantic or full-text
memory_add_tags — Organize with tags
memory_add_relation — Link related memories
memory_timeline — Trace chronological history
memory_compress — Deduplicate similar memories
... and 8 more

Comparison: Kore vs the Competition

Here's what sets Kore apart:

Feature	Kore	Mem0	Zep	ChromaDB
Fully offline	✅	❌	❌	✅
No LLM required	✅	❌	❌	✅
Ebbinghaus decay	✅	❌	❌	❌
Auto-importance (local)	✅	LLM	❌	❌
Memory compression	✅	❌	❌	❌
Semantic search (50+ langs)	✅	API	API	✅
Timeline API	✅	❌	❌	❌
Tags & Relations	✅	❌	❌	❌
TTL / Auto-expiration	✅	❌	❌	❌
MCP Server (Claude/Cursor)	✅	❌	❌	❌
Batch API	✅	❌	❌	❌
Web Dashboard	✅	✅	✅	❌
Runs locally in 2 minutes	✅	❌	❌	✅

Mem0 and Zep are enterprise solutions requiring cloud infra. ChromaDB is a vector store, not a memory system (no decay, no auto-importance). Kore is purpose-built for AI agents that need to remember intelligently.

Architecture: How It Works

POST /save
  │
  ├─ Parse + validate (Pydantic)
  │
  ├─ Auto-score importance
  │   ├─ Category baseline
  │   ├─ Keyword signals
  │   └─ Length bonus
  │
  ├─ Generate embedding (local sentence-transformers)
  │
  └─ Store in SQLite
      ├─ `memories` table (core data)
      ├─ `memories_fts` virtual table (FTS5 index)
      ├─ `memory_tags` (many-to-many)
      └─ `memory_relations` (knowledge graph)

GET /search?q=dark+mode
  │
  ├─ Encode query (same embedding model)
  │
  ├─ FTS5 keyword match (fast baseline)
  │
  ├─ Semantic search (cosine similarity)
  │
  ├─ Filter expired + decayed memories
  │
  ├─ Re-rank: score = similarity × decay × importance
  │
  └─ Return top-k + reinforce (access_count++, decay+0.05)

Key technical details:

FastAPI + SQLite (WAL mode for concurrency)
FTS5 full-text index with automatic triggers
Sentence-transformers (multilingual) with OOM protection
Connection pooling, parameterized queries, rate limiting
360 tests, 80%+ code coverage
Async/await support throughout

Dependencies: Just FastAPI, Uvicorn, Pydantic, httpx. Semantic search pulls in sentence-transformers (lazy-loaded, not required for basic FTS).

What Developers Are Using It For

LangChain Agents — Multi-turn conversations that remember context from previous sessions
CrewAI Teams — Persistent knowledge graph across agent interactions
AI Tutors — Remember student progress, learning style, misconceptions
Code Review Bots — Remember coding standards, team preferences, architectural patterns
Sales Agents — Customer history, preferences, deal context
Research Assistants — Literature notes, methodology choices, hypotheses
Claude/Cursor Plugins — Via MCP, extend Claude with custom memory

Real-world use case: A code review agent trained on a specific codebase. It uses Kore to remember:

Architectural decisions (importance 5, half-life 365 days)
Code patterns the team prefers (importance 4, half-life 90 days)
Past PRs that triggered discussions (importance 3, decays over time)
Linting rules (importance 5, never forget)

It searches for "async patterns" and finds relevant memories from 6 months ago, weighted by decay and importance. If it hasn't seen that memory in a while, decay reduces its score — exactly like human memory.

Getting Started: 4-Step Walkthrough

Step 1: Install

pip install kore-memory[semantic]

Step 2: Start the server

kore
# → Kore running on http://localhost:8765

Step 3: Open the dashboard

http://localhost:8765/dashboard

No login. Dark theme. Fully responsive. Try saving a memory. Try searching.

Step 4: Integrate with your agent

If you're using LangChain:

from kore_memory.integrations import KoreLangChainMemory
memory = KoreLangChainMemory("http://localhost:8765")
# Pass to your chain

If you're building custom:

from kore_memory import KoreClient
kore = KoreClient("http://localhost:8765")
kore.save("Important context", category="project")
results = kore.search("context")

Open Questions We Get Asked

Q: Does it use my data for training?
A: No. 100% offline. Nothing leaves your machine.

Q: Can I use this in production?
A: Yes. It's stable (v1.0.1), has 360 tests, and is used in production by several teams.

Q: What about LLM cost?
A: Zero. No API calls except to your own LLM (Claude, Llama, etc.).

Q: Can multiple agents share a server?
A: Yes. Agent namespace isolation via X-Agent-Id header. Each agent's memories are private.

Q: What's the latency?
A: Search latency is typically 10-50ms. Semantic search (with embeddings) is 50-200ms. No network roundtrips.

Q: How much data can I store?
A: SQLite handles millions of memories. We've tested with 100K+ memories with no performance degradation.

Q: Can I export my memories?
A: Yes. Full JSON export, import support, soft-delete/archive, TTL for auto-expiration.

Why We Built This

Traditional memory systems treat "forgetting" as a bug. They accumulate every interaction forever.

But human memory is smarter. You remember your first car's license plate (never accessed, slowly decays). You remember your spouse's birthday (constantly reinforced, never decays). You instantly forget meeting room numbers after leaving the building.

Kore brings that intelligence to AI agents. It's not just a vector store. It's a deliberate model of how memory should work.

Next Steps

Star on GitHub — github.com/auriti-labs/kore-memory
Install — pip install kore-memory[semantic]
JS SDK — npm install kore-memory-client
Documentation — auritidesign.it/docs/kore-memory
Contribute — Issues, PRs, and feature discussions welcome

The agent that remembers wins. Build one.

Questions? Comments? Hit me up on GitHub or reach out on dev.to.