feat: add pSEO generator, data and template

pseo/data.json

@@ -0,0 +1,34 @@
+{
+  "frameworks": [
+    "LangChain", "LlamaIndex", "AutoGPT", "CrewAI", "AutoGen",
+    "ChatGPT Plugins", "Claude API", "Gemini API", "Mistral AI",
+    "OpenAI Assistants", "Haystack", "Semantic Kernel", "Flowise",
+    "Dify", "AgentGPT", "BabyAGI", "SuperAGI", "Dust", "Vertex AI",
+    "AWS Bedrock", "Cohere API", "Ollama", "LM Studio", "PrivateGPT"
+  ],
+  "use_cases": [
+    "Customer Support Bot", "Coding Assistant", "Medical Diagnosis AI",
+    "Legal Research AI", "Financial Advisor AI", "HR Onboarding Bot",
+    "Sales CRM AI", "Educational Tutor AI", "Mental Health Chatbot",
+    "Personal AI Assistant", "Research Summarizer", "Document Q&A Bot",
+    "Call Center AI", "E-commerce Recommendation AI", "Security Analyst AI",
+    "DevOps Incident Response AI", "Content Writing Assistant",
+    "Meeting Notes AI", "Email Drafting AI", "Contract Review AI"
+  ],
+  "problems": [
+    "AI forgets context between sessions",
+    "chatbot loses memory after restart",
+    "LLM cannot remember past conversations",
+    "AI agent has no long-term memory",
+    "vector database not preserving conversation history",
+    "RAG system missing temporal context",
+    "AI cannot recall user preferences",
+    "GPT loses thread after token limit",
+    "agent memory resets every session",
+    "AI cannot trace cause and effect in conversations"
+  ],
+  "comparisons": [
+    "Redis", "Pinecone", "Weaviate", "Chroma", "Qdrant",
+    "PostgreSQL", "MongoDB", "Zep", "Mem0", "MemGPT"
+  ]
+}

pseo/generate_pages.py

@@ -0,0 +1,142 @@
+"""
+Smriti pSEO Page Generator
+Generates hundreds of targeted landing pages from data.json + template.html
+
+Usage:
+    python generate_pages.py              # generates all pages
+    python generate_pages.py --batch 50   # generates first 50 (for staged publishing)
+    python generate_pages.py --type framework  # only framework pages
+"""
+import json, os, re, sys, argparse
+from pathlib import Path
+
+BASE   = Path(__file__).parent
+DATA   = json.loads((BASE / "data.json").read_text())
+TMPL   = (BASE / "template.html").read_text()
+OUT    = BASE / "pages"
+OUT.mkdir(exist_ok=True)
+
+def slug(text):
+    return re.sub(r'[^a-z0-9]+', '-', text.lower()).strip('-')
+
+def fill(template, tokens):
+    for k, v in tokens.items():
+        template = template.replace("{{" + k + "}}", v)
+    return template
+
+# ── PAGE TYPES ────────────────────────────────────────────────────────────────
+
+def framework_page(name):
+    s = slug(name)
+    t = {
+        "PAGE_TITLE":       f"{name} Persistent Memory — Smriti",
+        "META_DESCRIPTION": f"Add long-term, causal memory to {name} using Smriti's dual pgvector architecture. S-V-O extraction. Cross-session retention. O(1) recall.",
+        "SLUG":             f"memory/{s}",
+        "H1_HEADLINE":      f"Add Persistent Memory to <span>{name}</span>",
+        "HERO_SUBTEXT":     f"Give your {name} agent a brain. Smriti adds long-term, causal memory — retaining context across every session, understanding why events happened, not just what happened.",
+        "PROBLEM_TEXT":     f"{name} agents lose all context when a session ends. Every conversation starts from zero. Users repeat themselves, agents forget preferences, and causal connections between events disappear entirely.",
+        "SOLUTION_TEXT":    f"Smriti integrates directly with {name} as a drop-in memory layer. It extracts Subject-Verb-Object triples from every interaction, stores them in a dual semantic and episodic pgvector space, and retrieves causal context in O(1) time — across any number of sessions.",
+        "HOW_IT_WORKS":     f"{name} calls Smriti's memory API before generating any response. Smriti checks its timeline, retrieves relevant causal context, and passes it as structured memory to the {name} prompt. The agent responds with full awareness of past events — not just the last message.",
+        "TARGET_NAME":      name,
+        "TARGET_SLUG":      s,
+        "COMPARISON_NAME":  "Standard Vector DB",
+        "SEO_H2_1":         f"Why {name} needs long-term memory",
+        "SEO_PARA_1":       f"{name} is a powerful AI framework but lacks persistent, cross-session memory by default. Each agent run begins with no knowledge of previous interactions. For production applications — customer support, personal assistants, research tools — this is a critical limitation. Smriti solves this by maintaining a chronological memory timeline that persists indefinitely.",
+        "SEO_H2_2":         f"How Smriti's S-V-O architecture improves {name} agents",
+        "SEO_PARA_2":       f"Unlike simple vector search that retrieves semantically similar text, Smriti extracts the Subject-Verb-Object structure from every stored memory. This means a {name} agent can answer causal questions: not just 'what happened?' but 'why did it happen?' and 'what was the consequence?' This is the difference between a database and a timeline.",
+        "SEO_H2_3":         f"Getting started with Smriti and {name}",
+        "SEO_PARA_3":       f"Smriti installs as a Python package and integrates with {name} in under 10 lines of code. It requires a PostgreSQL instance with pgvector enabled. Memory is stored in two parallel vector spaces — one for semantic meaning, one for episodic cause-and-effect — giving {name} agents both broad recall and precise causal reasoning.",
+    }
+    return s, t
+
+def usecase_page(name):
+    s = slug(name)
+    t = {
+        "PAGE_TITLE":       f"{name} with Long-Term Memory — Smriti",
+        "META_DESCRIPTION": f"Build a {name} that actually remembers. Smriti adds persistent, causal memory to any AI system — cross-session, encrypted, O(1) retrieval.",
+        "SLUG":             f"use-case/{s}",
+        "H1_HEADLINE":      f"Build a <span>{name}</span> That Actually Remembers",
+        "HERO_SUBTEXT":     f"Most AI-powered {name.lower()} systems forget everything when the session ends. Smriti gives your {name.lower()} a persistent timeline — so it understands context, cause, and consequence.",
+        "PROBLEM_TEXT":     f"A {name.lower()} that forgets its users is not intelligent — it is a search engine with a chat interface. Every session reset destroys trust, increases user friction, and makes the system feel broken.",
+        "SOLUTION_TEXT":    f"Smriti gives your {name.lower()} a persistent causal memory. Every interaction is stored as a Subject-Verb-Object triple on a chronological timeline. When a user returns after days or weeks, the system remembers not just what happened — but why.",
+        "HOW_IT_WORKS":     f"For a {name.lower()}, Smriti stores the full history of every user interaction in a dual pgvector space. When the user asks a question, Smriti retrieves the most causally relevant memories — not just the most recent ones — and passes them to your language model as structured context.",
+        "TARGET_NAME":      name,
+        "TARGET_SLUG":      s,
+        "COMPARISON_NAME":  "Session-Only Memory",
+        "SEO_H2_1":         f"Why {name.lower()} AI systems fail without long-term memory",
+        "SEO_PARA_1":       f"The majority of {name.lower()} AI systems today rely on in-session context windows. Once the session ends, all memory is lost. Users are forced to repeat their preferences, history, and background every time they interact. This creates frustration and destroys the value of AI personalization.",
+        "SEO_H2_2":         f"Smriti's causal memory model for {name.lower()} applications",
+        "SEO_PARA_2":       f"Smriti does not simply store and retrieve text. It extracts the causal structure of every interaction — who did what, when, and why — and organises these events on a chronological timeline. For a {name.lower()}, this means the AI can answer questions like 'why did this user's situation change?' with real contextual evidence.",
+        "SEO_H2_3":         f"Technical architecture for {name.lower()} memory with Smriti",
+        "SEO_PARA_3":       f"Smriti uses a dual pgvector architecture. The semantic space captures meaning and similarity. The episodic space captures temporal ordering and causal relationships. For a {name.lower()}, this means both fuzzy recall ('something about pricing') and precise recall ('the user asked about pricing after their contract expired') are supported simultaneously.",
+    }
+    return s, t
+
+def problem_page(problem):
+    s = slug(problem)
+    t = {
+        "PAGE_TITLE":       f"Fix: {problem.capitalize()} — Smriti Memory",
+        "META_DESCRIPTION": f"Solving the problem: {problem}. Smriti's S-V-O timeline architecture gives AI systems persistent causal memory across sessions.",
+        "SLUG":             f"problem/{s}",
+        "H1_HEADLINE":      f"Why <span>{problem.capitalize()}</span> — And How to Fix It",
+        "HERO_SUBTEXT":     f"This is not a bug in your AI. It is a fundamental architectural gap. Smriti fills it with a persistent causal memory layer built on dual pgvector and S-V-O extraction.",
+        "PROBLEM_TEXT":     f"The root cause of '{problem}' is that most AI systems store context in a session-scoped token window — not in a persistent, structured timeline. When the session ends, the context is gone. There is no mechanism for causal recall across time.",
+        "SOLUTION_TEXT":    f"Smriti replaces the ephemeral context window with a persistent S-V-O timeline. Every interaction is extracted into a Subject-Verb-Object triple and stored in a dual semantic/episodic pgvector space. Sessions end — memory does not.",
+        "HOW_IT_WORKS":     f"When your AI encounters the situation '{problem}', Smriti's memory layer already has the relevant context indexed. It retrieves it in O(1) time and injects it into the prompt as structured causal memory — no session required.",
+        "TARGET_NAME":      problem.capitalize(),
+        "TARGET_SLUG":      s,
+        "COMPARISON_NAME":  "Session Context Window",
+        "SEO_H2_1":         f"Root cause: why '{problem}' happens in AI systems",
+        "SEO_PARA_1":       f"The problem of '{problem}' is endemic to LLM-based systems that store state in the prompt context window rather than in a persistent external memory store. Context windows have hard token limits, are session-scoped, and provide no mechanism for causal reasoning across time. The result is an AI that cannot remember, cannot reason about the past, and cannot maintain continuity.",
+        "SEO_H2_2":         "The S-V-O timeline: a structural solution",
+        "SEO_PARA_2":       f"Smriti addresses '{problem}' at the architectural level by replacing the context window as the primary memory store. Instead, every interaction is parsed into a Subject-Verb-Object triple — capturing who did what to whom — and placed on a persistent chronological timeline stored in PostgreSQL with pgvector indexing. This structure enables causal queries that a flat vector store cannot answer.",
+        "SEO_H2_3":         "Implementation: integrating Smriti to solve this problem",
+        "SEO_PARA_3":       f"Integrating Smriti to fix '{problem}' requires three steps. First, install the Smriti Python package and configure a pgvector-enabled PostgreSQL database. Second, replace your in-session context injection with Smriti's memory.recall() call, which returns causally-relevant context from the full timeline. Third, use memory.store() after every interaction to keep the timeline current. The fix is additive — no existing code needs to be removed.",
+    }
+    return s, t
+
+# ── GENERATE ─��────────────────────────────────────────────────────────────────
+
+def generate_all(page_type=None, batch=None):
+    pages = []
+
+    if page_type in (None, 'framework'):
+        for name in DATA['frameworks']:
+            s, t = framework_page(name)
+            pages.append(('framework', s, t))
+
+    if page_type in (None, 'usecase'):
+        for name in DATA['use_cases']:
+            s, t = usecase_page(name)
+            pages.append(('usecase', s, t))
+
+    if page_type in (None, 'problem'):
+        for prob in DATA['problems']:
+            s, t = problem_page(prob)
+            pages.append(('problem', s, t))
+
+    if batch:
+        pages = pages[:batch]
+
+    total = 0
+    for ptype, s, tokens in pages:
+        folder = OUT / ptype
+        folder.mkdir(exist_ok=True)
+        html = fill(TMPL, tokens)
+        path = folder / f"{s}.html"
+        path.write_text(html, encoding='utf-8')
+        print(f"[OK] {ptype}/{s}.html")
+        total += 1
+
+    print(f"\n[DONE] Generated {total} pages -> {OUT}")
+    print(f"       Frameworks : {len(DATA['frameworks'])}")
+    print(f"       Use cases  : {len(DATA['use_cases'])}")
+    print(f"       Problems   : {len(DATA['problems'])}")
+    print(f"       TOTAL POSSIBLE : {len(DATA['frameworks'])+len(DATA['use_cases'])+len(DATA['problems'])}")
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--batch', type=int, default=None, help='Only generate first N pages')
+    ap.add_argument('--type', choices=['framework','usecase','problem'], default=None)
+    args = ap.parse_args()
+    generate_all(page_type=args.type, batch=args.batch)

pseo/template.html

@@ -0,0 +1,222 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"/>
+<meta name="viewport" content="width=device-width,initial-scale=1.0"/>
+<title>{{PAGE_TITLE}} | Smriti Memory Architecture</title>
+<meta name="description" content="{{META_DESCRIPTION}}"/>
+<meta property="og:title" content="{{PAGE_TITLE}}"/>
+<meta property="og:description" content="{{META_DESCRIPTION}}"/>
+<meta property="og:type" content="article"/>
+<link rel="canonical" href="https://smriti.dev/{{SLUG}}"/>
+<link rel="preconnect" href="https://fonts.googleapis.com"/>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;800&family=JetBrains+Mono:wght@400;700&display=swap" rel="stylesheet"/>
+<style>
+*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+body{background:#050509;color:#fff;font-family:'Inter',sans-serif;line-height:1.6}
+
+/* Nav */
+nav{padding:20px 40px;display:flex;align-items:center;justify-content:space-between;
+    border-bottom:1px solid rgba(255,255,255,.06)}
+.logo{font-weight:800;font-size:20px;color:#00f5d4;letter-spacing:-.02em}
+.nav-link{color:rgba(255,255,255,.5);text-decoration:none;font-size:14px;
+           transition:color .2s}
+.nav-link:hover{color:#fff}
+
+/* Hero */
+.hero{max-width:860px;margin:80px auto 60px;padding:0 40px;text-align:center}
+.badge{display:inline-block;padding:6px 16px;border-radius:20px;font-size:12px;
+       font-weight:600;letter-spacing:.1em;text-transform:uppercase;
+       background:rgba(0,245,212,.1);color:#00f5d4;border:1px solid rgba(0,245,212,.2);
+       margin-bottom:28px}
+h1{font-size:clamp(32px,5vw,56px);font-weight:800;line-height:1.15;
+   letter-spacing:-.03em;margin-bottom:24px}
+h1 span{color:#00f5d4}
+.hero-sub{font-size:20px;font-weight:300;color:rgba(255,255,255,.65);
+          max-width:620px;margin:0 auto 40px}
+.cta-row{display:flex;gap:16px;justify-content:center;flex-wrap:wrap}
+.btn-primary{padding:14px 32px;border-radius:10px;font-size:16px;font-weight:600;
+             background:#00f5d4;color:#050509;text-decoration:none;transition:.2s}
+.btn-primary:hover{background:#00d4b8}
+.btn-ghost{padding:14px 32px;border-radius:10px;font-size:16px;font-weight:600;
+           border:1px solid rgba(255,255,255,.15);color:#fff;text-decoration:none;
+           transition:.2s}
+.btn-ghost:hover{border-color:rgba(255,255,255,.4)}
+
+/* Stats */
+.stats{display:flex;gap:40px;justify-content:center;padding:40px;flex-wrap:wrap;
+       border-top:1px solid rgba(255,255,255,.06);border-bottom:1px solid rgba(255,255,255,.06)}
+.stat{text-align:center}
+.stat-num{font-size:36px;font-weight:800;color:#00f5d4}
+.stat-label{font-size:13px;color:rgba(255,255,255,.45);margin-top:4px}
+
+/* Content */
+.content{max-width:860px;margin:0 auto;padding:60px 40px}
+h2{font-size:28px;font-weight:800;margin:48px 0 16px;letter-spacing:-.02em}
+h2:first-child{margin-top:0}
+p{color:rgba(255,255,255,.72);margin-bottom:16px;font-size:17px}
+.highlight{color:#fff;font-weight:600}
+
+/* Problem / Solution boxes */
+.card{background:rgba(255,255,255,.03);border:1px solid rgba(255,255,255,.07);
+      border-radius:14px;padding:28px;margin:24px 0}
+.card.problem{border-color:rgba(255,48,120,.2);background:rgba(255,48,120,.04)}
+.card.solution{border-color:rgba(0,245,212,.2);background:rgba(0,245,212,.04)}
+.card-label{font-size:12px;font-weight:700;letter-spacing:.12em;text-transform:uppercase;
+            margin-bottom:12px}
+.card.problem .card-label{color:#ff3066}
+.card.solution .card-label{color:#00f5d4}
+.card p{margin:0;color:rgba(255,255,255,.8)}
+
+/* Code block */
+.code-block{background:#0a0a12;border:1px solid rgba(255,255,255,.08);border-radius:10px;
+            padding:24px;margin:24px 0;overflow-x:auto}
+.code-block code{font-family:'JetBrains Mono',monospace;font-size:14px;
+                 color:#00f5d4;line-height:1.7}
+.code-comment{color:rgba(255,255,255,.3)}
+
+/* Comparison table */
+.compare-table{width:100%;border-collapse:collapse;margin:24px 0;font-size:15px}
+.compare-table th{padding:14px 20px;text-align:left;font-weight:600;font-size:12px;
+                  text-transform:uppercase;letter-spacing:.1em;
+                  color:rgba(255,255,255,.4);border-bottom:1px solid rgba(255,255,255,.08)}
+.compare-table td{padding:14px 20px;border-bottom:1px solid rgba(255,255,255,.04)}
+.compare-table tr:last-child td{border-bottom:none}
+.tick{color:#00f5d4;font-weight:700}
+.cross{color:#ff3066}
+.col-smriti{background:rgba(0,245,212,.04)}
+
+/* Footer */
+footer{padding:40px;text-align:center;border-top:1px solid rgba(255,255,255,.06);
+       color:rgba(255,255,255,.3);font-size:14px;margin-top:80px}
+footer a{color:#00f5d4;text-decoration:none}
+
+/* SEO article (visible to Google, subtle to users) */
+.seo-article{max-width:860px;margin:0 auto;padding:0 40px 60px;
+             color:rgba(255,255,255,.45);font-size:15px}
+.seo-article h3{font-size:18px;font-weight:600;color:rgba(255,255,255,.6);
+                margin:32px 0 12px}
+</style>
+</head>
+<body>
+
+<!-- Navigation -->
+<nav>
+  <span class="logo">smriti</span>
+  <a href="/docs" class="nav-link">Docs</a>
+</nav>
+
+<!-- Hero -->
+<section class="hero">
+  <div class="badge">Memory Architecture</div>
+  <h1>{{H1_HEADLINE}}</h1>
+  <p class="hero-sub">{{HERO_SUBTEXT}}</p>
+  <div class="cta-row">
+    <a href="/docs/quickstart" class="btn-primary">Read the Docs</a>
+    <a href="/node97" class="btn-ghost">Watch Explainer</a>
+  </div>
+</section>
+
+<!-- Stats -->
+<div class="stats">
+  <div class="stat"><div class="stat-num">O(1)</div><div class="stat-label">Connection Retrieval</div></div>
+  <div class="stat"><div class="stat-num">S-V-O</div><div class="stat-label">Extraction Engine</div></div>
+  <div class="stat"><div class="stat-num">Dual</div><div class="stat-label">pgvector Architecture</div></div>
+  <div class="stat"><div class="stat-num">∞</div><div class="stat-label">Context Retention</div></div>
+</div>
+
+<!-- Main Content -->
+<div class="content">
+
+  <div class="card problem">
+    <div class="card-label">The Problem</div>
+    <p>{{PROBLEM_TEXT}}</p>
+  </div>
+
+  <div class="card solution">
+    <div class="card-label">The Smriti Solution</div>
+    <p>{{SOLUTION_TEXT}}</p>
+  </div>
+
+  <h2>How It Works with {{TARGET_NAME}}</h2>
+  <p>{{HOW_IT_WORKS}}</p>
+
+  <div class="code-block">
+    <code>
+<span class="code-comment"># Install Smriti</span>
+pip install smriti
+
+<span class="code-comment"># Initialize with {{TARGET_SLUG}}</span>
+from smriti import SmritiMemory
+
+memory = SmritiMemory(
+    backend="pgvector",
+    mode="dual",          <span class="code-comment"># semantic + episodic</span>
+    svo_extraction=True   <span class="code-comment"># auto S-V-O tagging</span>
+)
+
+<span class="code-comment"># Store any interaction</span>
+memory.store("User bought flowers on Tuesday")
+
+<span class="code-comment"># Retrieve with causal context</span>
+result = memory.recall("why did we argue on Friday?")
+<span class="code-comment"># Returns: Tuesday → flowers → context → Friday</span>
+    </code>
+  </div>
+
+  <h2>Smriti vs {{COMPARISON_NAME}}</h2>
+  <table class="compare-table">
+    <thead>
+      <tr>
+        <th>Feature</th>
+        <th>{{COMPARISON_NAME}}</th>
+        <th class="col-smriti">Smriti</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td>Long-term memory</td>
+        <td><span class="cross">Partial</span></td>
+        <td class="col-smriti"><span class="tick">Full timeline</span></td>
+      </tr>
+      <tr>
+        <td>Causal context (A caused B)</td>
+        <td><span class="cross">No</span></td>
+        <td class="col-smriti"><span class="tick">S-V-O graph</span></td>
+      </tr>
+      <tr>
+        <td>Cross-session retention</td>
+        <td><span class="cross">Session only</span></td>
+        <td class="col-smriti"><span class="tick">Persistent</span></td>
+      </tr>
+      <tr>
+        <td>Encrypted memory blocks</td>
+        <td><span class="cross">No</span></td>
+        <td class="col-smriti"><span class="tick">Block-level</span></td>
+      </tr>
+      <tr>
+        <td>Query speed</td>
+        <td>O(n) scan</td>
+        <td class="col-smriti"><span class="tick">O(1) via index</span></td>
+      </tr>
+    </tbody>
+  </table>
+
+</div>
+
+<!-- SEO Article (crawlable text) -->
+<article class="seo-article">
+  <h3>{{SEO_H2_1}}</h3>
+  <p>{{SEO_PARA_1}}</p>
+  <h3>{{SEO_H2_2}}</h3>
+  <p>{{SEO_PARA_2}}</p>
+  <h3>{{SEO_H2_3}}</h3>
+  <p>{{SEO_PARA_3}}</p>
+</article>
+
+<footer>
+  Built by <a href="/">Chronos OS</a> · Smriti Memory Architecture · Node 97
+</footer>
+
+</body>
+</html>