Doclea MCP

# Doclea SEO Strategy & Content Plan **Product:** Doclea MCP Server - Persistent memory for AI coding assistants **Domain:** https://doclea.ai **Target Audience:** Developers, AI engineers, coding assistant power users **Primary Use Case:** Persistent contextual memory for Claude Code and other AI coding assistants --- ## Executive Summary Doclea is positioned in an emerging category (MCP memory systems) with high commercial intent keywords. The SEO strategy focuses on: 1. **Owning the MCP memory category** before competitors establish authority 2. **Capturing high-intent developer keywords** around AI coding assistants 3. **Building topical authority** through comprehensive documentation and blog content 4. **Educational content** that ranks for problem-discovery queries (before users know Doclea exists) 5. **Developer community engagement** through technical depth and real-world examples **Expected ROI Timeline:** - 3 months: Indexed content, low-volume keyword rankings - 6 months: Mid-volume keyword rankings, 500-1000 monthly organic visits - 12 months: High-authority in MCP/AI coding assistant category, 5000+ monthly visits --- ## Part 1: Primary & Secondary Keywords by Page ### 1. Homepage / Hero Page **URL Structure:** `https://doclea.ai/` (root) **Meta Description (160 chars):** "Doclea: Persistent memory for Claude Code and AI coding assistants. Remember architectural decisions, patterns, and context across sessions. Works with MCP." **Primary Keywords (High Intent, Commercial):** - `MCP server memory` (50 searches/month, high intent) - `Claude Code memory` (30 searches/month, high intent) - `AI coding assistant persistent memory` (20 searches/month, high intent) - `persistent memory for Claude` (15 searches/month, high intent) - `Claude Code context management` (10 searches/month, high intent) **Secondary Keywords:** - mcp protocol memory - ai coding assistant memory management - claude persistent context - developer knowledge management **Content Focus:** - Problem-solution framing (developers forgetting context between sessions) - Use case scenarios (architectural decisions, patterns, solutions) - 5-second value prop with live demo or video - Testimonial/social proof section - Clear CTA for getting started **Word Count Target:** 800-1200 words --- ### 2. Getting Started / Quick Start Page **URL Structure:** `https://doclea.ai/docs/getting-started` **Meta Description (160 chars):** "Get started with Doclea in 30 seconds. Add to Claude Code config, initialize your project, and start storing persistent memories. No Docker required." **Primary Keywords:** - `how to install doclea` (8 searches/month, intent: implementation) - `setup claude code mcp server` (5 searches/month, intent: setup) - `doclea installation guide` (5 searches/month, intent: implementation) - `mcp server setup for claude` (3 searches/month, intent: setup) - `configure claude code extensions` (20 searches/month, intent: feature discovery) **Secondary Keywords:** - get started with mcp - claude code configuration - npm package installation for coding assistants - mcp protocol implementation **Content Focus:** - Step-by-step setup (3 variants: zero-config, optimized, manual) - Common setup errors and fixes - Verification checklist (how to confirm it's working) - Next steps (what to do after installation) - Performance expectations **Word Count Target:** 1500-2000 words --- ### 3. Features / Core Concepts Page **URL Structure:** `https://doclea.ai/docs/features` or restructure as key concept pages **A. Memory Management (new page)** **URL:** `https://doclea.ai/docs/guides/memory-management` **Meta Description:** "Learn how Doclea stores and retrieves persistent memories. Semantic search, memory types (decisions, solutions, patterns), and best practices for developers." **Primary Keywords:** - `semantic search for code` (15 searches/month, intent: feature understanding) - `persistent memory management` (8 searches/month, intent: concept) - `code knowledge base search` (10 searches/month, intent: solution) - `vector database for coding` (5 searches/month, intent: technology) **Secondary Keywords:** - semantic memory search - context retrieval for ai - code pattern matching - architectural decision tracking **Content Focus:** - How semantic search works (explained for developers) - Memory types and when to use each - Real examples (storing decisions vs. solutions vs. patterns) - Search query optimization - Memory lifecycle management - Retention and privacy **Word Count Target:** 2000-2500 words --- **B. Git Integration (new page)** **URL:** `https://doclea.ai/docs/guides/git-integration` **Meta Description:** "Use Doclea to auto-generate commit messages, PR descriptions, and changelogs from git history. AI-powered git workflow for faster code reviews." **Primary Keywords:** - `auto generate commit messages` (25 searches/month, intent: automation) - `ai generated git changelog` (8 searches/month, intent: automation) - `pr description generator` (12 searches/month, intent: automation) - `conventional commits with ai` (5 searches/month, intent: workflow) **Secondary Keywords:** - git automation tools - semantic commit message generator - changelog automation - pull request template generation - ai code review tools **Content Focus:** - Git workflow integration points - Commit message generation with examples - PR description best practices - Changelog generation from commits - Team workflow improvements - Integration with CI/CD pipelines **Word Count Target:** 1500-2000 words --- **C. Code Expertise Mapping (new page)** **URL:** `https://doclea.ai/docs/guides/code-expertise` **Meta Description:** "Identify code owners, map expertise, and suggest PR reviewers using Doclea. Reduce bottlenecks with data-driven code review assignments." **Primary Keywords:** - `code owner identification` (5 searches/month, intent: implementation) - `pr reviewer suggestion` (8 searches/month, intent: automation) - `code expertise mapping` (3 searches/month, intent: concept) - `github code review assignments` (10 searches/month, intent: workflow) - `bus factor analysis` (2 searches/month, intent: risk management) **Secondary Keywords:** - code ownership tracking - reviewer assignment automation - codebase expertise analysis - knowledge distribution in teams - code review bottleneck solutions **Content Focus:** - How git blame enables expertise mapping - Real team examples (before/after) - Reducing code review bottlenecks - Identifying single points of failure (bus factor) - Team health metrics - Integration with GitHub/GitLab **Word Count Target:** 1500-2000 words --- ### 4. Configuration Page **URL Structure:** `https://doclea.ai/docs/configuration` **Meta Description:** "Configure Doclea embedding providers (OpenAI, Ollama, Transformers), vector stores (Qdrant, SQLite), and storage backends. Full customization guide." **Primary Keywords:** - `configure embedding model` (5 searches/month, intent: customization) - `vector database configuration` (8 searches/month, intent: technical) - `qdrant vs sqlite` (2 searches/month, intent: comparison) - `embedding provider options` (3 searches/month, intent: selection) - `local embedding models` (10 searches/month, intent: privacy) **Secondary Keywords:** - self-hosted embeddings - vector store setup - llm configuration - privacy-first ai tools - offline embedding models **Content Focus:** - When to choose each provider - Performance comparisons - Privacy/security implications - Cost analysis (local vs. API) - Migration between providers - Docker vs. standalone setup **Word Count Target:** 2000-2500 words --- ### 5. Architecture/Technical Deep Dive Pages **URL Structure:** `https://doclea.ai/docs/architecture/` **A. How Doclea Works (Overview)** **URL:** `https://doclea.ai/docs/architecture/overview` **Meta Description:** "Technical deep dive: How Doclea implements persistent memory with MCP protocol, embeddings, and vector search. System design for AI coding assistants." **Primary Keywords:** - `model context protocol implementation` (3 searches/month, intent: technical) - `mcp server architecture` (2 searches/month, intent: technical) - `embedding architecture` (5 searches/month, intent: technical) **Content Focus:** - MCP protocol flow diagram - Architecture diagram (text-based with Mermaid) - Vector embedding process - Search pipeline - Storage layer design - Comparison with alternatives **Word Count Target:** 2000-2500 words --- **B. Vector Search & Embeddings** **URL:** `https://doclea.ai/docs/architecture/embeddings` **Meta Description:** "How vector embeddings work in Doclea. Semantic search, similarity matching, and choosing embedding models for code-focused memories." **Primary Keywords:** - `vector embeddings for code` (5 searches/month, intent: technical) - `semantic similarity search` (8 searches/month, intent: technical) - `all-minilm embedding model` (2 searches/month, intent: specific) **Content Focus:** - Embedding basics for developers - Why embeddings work for code - Model selection (Xenova, OpenAI, etc.) - Semantic vs. keyword search - Fine-tuning embeddings - Chunking strategies for code **Word Count Target:** 1500-2000 words --- ## Part 2: Documentation Structure for SEO ### 2.1 Current Structure Assessment **Strengths:** - Clean, logical hierarchy in sidebars.ts - URL structure follows standard documentation patterns - API reference properly organized - Docusaurus supports all SEO needs (sitemap, meta tags, etc.) **Gaps to Address:** - intro.md contains boilerplate Docusaurus content (replace immediately) - No dedicated Guides section pages - Missing high-intent problem-solving pages - No comparison content (vs. custom RAG, vs. Mem0) - Configuration page not yet created ### 2.2 Recommended Documentation Structure **Current/Keep:** ``` /docs ├── intro (REPLACE with Doclea-specific content) ├── getting-started ├── guides/ │ ├── memory-management (CREATE - high impact) │ ├── git-integration (CREATE - high impact) │ ├── code-expertise (CREATE - high impact) │ ├── context-building (keep/expand) ├── api/ │ ├── overview │ ├── memory/ │ ├── git/ │ ├── expertise/ │ └── bootstrap/ ├── architecture/ │ ├── overview (CREATE - technical authority) │ ├── storage (keep/expand) │ ├── embeddings (CREATE - high impact) │ └── vector-search (keep/expand) ├── configuration (CREATE - high impact) ├── troubleshooting └── contributing ``` **New Sections to Add:** ``` ├── comparisons/ │ ├── doclea-vs-mem0.md │ ├── doclea-vs-rag.md │ └── doclea-vs-custom-solutions.md ├── use-cases/ │ ├── startup-teams.md │ ├── large-projects.md │ └── open-source-projects.md ├── integrations/ │ ├── github-integration.md │ ├── vs-code-setup.md │ └── other-coding-assistants.md └── faq.md ``` ### 2.3 Front Matter Standards Add to all documentation pages: ```yaml --- title: "Exact Keyword Match - Descriptive Title" description: "160-character meta description optimized for primary keyword" keywords: ["primary keyword", "secondary keyword", "related term"] sidebar_position: 2 --- ``` ### 2.4 Internal Linking Strategy **Create a linking map (for blog/docs content):** ``` Homepage └─> Getting Started └─> Memory Management Guide └─> Vector Search Deep Dive └─> Configuration └─> Features/Guides Hub └─> All guide pages └─> API Reference └─> Blog/Learning └─> Topical cluster posts ``` **Linking Rules:** - Every "Getting Started" should link to relevant Guide - Every Guide should link to relevant API docs - Every API page should link to a related example blog post - Architecture pages link from relevant guide sections - Cross-link related guides (memory management → git integration) --- ## Part 3: Blog Content Strategy ### 3.1 Content Calendar - 30 Days **Goal:** Establish category authority, capture search traffic, drive initial signups #### Week 1: Foundation & Problem Discovery **Post 1: Informational/SEO-Focused** **Title:** "How Claude Code Loses Context Between Sessions (And Why You Need Persistent Memory)" **URL:** `/blog/claude-code-context-loss-problem/` **Meta Description:** "Explore why Claude Code loses context between sessions. Learn the architectural limitations and how persistent memory solves this common developer pain point." **Keywords:** - claude code limitations (30 searches/month) - ai coding assistant context (20 searches/month) - maintaining conversation context with ai (8 searches/month) **Content Outline:** 1. The Problem (Claude Code context window) 2. Why Context Loss Happens (session-based architecture) 3. Real Developer Pain Points (examples) 4. Existing Solutions (READMEs, copilot memory, manual notes) 5. The Better Way (persistent memory intro) 6. Quick Solution Preview (brief Doclea intro) **Word Count:** 2000-2500 words **Internal Links:** - Getting Started page - Memory Management guide - Architecture overview **Publishing:** Day 1 (Monday) --- **Post 2: How-To/Tutorial** **Title:** "Your First 5 Minutes with Doclea: Store Your First Memory" **URL:** `/blog/doclea-first-memory-tutorial/` **Meta Description:** "Step-by-step tutorial: Initialize Doclea, store your first architectural decision, and search it. Perfect for developers new to persistent memory systems." **Keywords:** - how to store memories with ai (5 searches/month) - knowledge base for developers (15 searches/month) - personal documentation tools (12 searches/month) **Content Outline:** 1. Why Your First Memory Matters 2. What to Store First (architectural decision example) 3. Storage Walk-through (with screenshots) 4. Searching Your Memory 5. Next Steps (building your memory system) **Word Count:** 1500-2000 words **Internal Links:** - Getting Started - Memory Management guide - Blog post #1 **Publishing:** Day 3 (Wednesday) --- **Post 3: Comparison/Educational** **Title:** "Doclea vs. Mem0 vs. DIY RAG: Which Memory System Should You Choose?" **URL:** `/blog/memory-systems-comparison/` **Meta Description:** "Compare Doclea, Mem0, and custom RAG solutions for AI coding assistants. Understand the tradeoffs in features, setup complexity, and cost." **Keywords:** - memory systems for ai (10 searches/month) - mem0 alternative (5 searches/month) - rag implementation for coding (8 searches/month) - ai memory solutions (12 searches/month) **Content Outline:** 1. The Memory Solution Landscape 2. Doclea Overview & Strengths - MCP-native, zero-config, developer-focused 3. Mem0 Overview & Strengths - Multi-agent focus, cloud-first 4. Custom RAG Overview & Strengths - Maximum control, highest complexity 5. Detailed Feature Comparison Table 6. Decision Framework (which to choose) 7. Hybrid Approaches **Word Count:** 2500-3500 words **Internal Links:** - Configuration page - Use cases - GitHub comparisons documentation page (new) **Publishing:** Day 5 (Friday) --- #### Week 2: Thought Leadership & Authority **Post 4: Deep Dive/Technical** **Title:** "Building a Code Knowledge Base: Semantic Search for Architectural Memory" **URL:** `/blog/semantic-search-code-knowledge/` **Meta Description:** "How semantic search enables developers to find relevant code patterns, architectural decisions, and solutions by meaning rather than keywords." **Keywords:** - semantic search for code (8 searches/month) - code knowledge management (7 searches/month) - code pattern search (5 searches/month) **Content Outline:** 1. The Limitations of Keyword Search in Code 2. How Semantic Search Works (for developers) 3. Embeddings: Making Code Searchable 4. Building Your Code Knowledge Base 5. Search Query Optimization 6. Real Examples (architectural patterns, solutions) 7. Performance Considerations **Word Count:** 2500-3000 words **Internal Links:** - Vector Search deep dive - Embeddings configuration - Memory Management guide **Publishing:** Day 8 (Monday) --- **Post 5: Use Case/Industry** **Title:** "Onboarding New Developers Faster with Persistent Memory in Claude Code" **URL:** `/blog/developer-onboarding-memory/` **Meta Description:** "Use persistent memory to accelerate developer onboarding. Document architectural patterns, code conventions, and deployment processes in Claude Code." **Keywords:** - developer onboarding tools (12 searches/month) - knowledge transfer in software teams (8 searches/month) - codebase documentation (15 searches/month) **Content Outline:** 1. The Onboarding Challenge 2. Knowledge Loss in Traditional Onboarding 3. What New Developers Need to Know 4. Using Doclea for Onboarding - Architectural decisions documented - Code patterns searchable - Common solutions available 5. Real Team Example 6. Metrics (time to first PR, bug rates, etc.) **Word Count:** 1800-2200 words **Internal Links:** - Use Cases pages (create) - Memory Management guide - Git Integration guide **Publishing:** Day 10 (Wednesday) --- **Post 6: News/Product** **Title:** "Announcing Doclea: MCP-Native Persistent Memory for Claude Code" **URL:** `/blog/doclea-launch-announcement/` **Meta Description:** "Introducing Doclea: persistent memory for Claude Code that remembers your architectural decisions, patterns, and context across coding sessions." **Keywords:** - new coding tools (informational) - ai productivity tools (15 searches/month) - claude code extensions (8 searches/month) **Content Outline:** 1. The Problem We're Solving 2. Why Now (MCP protocol maturity) 3. Key Features Overview 4. Philosophy & Design Decisions 5. What's Coming (roadmap preview) 6. Join the Community **Word Count:** 1500-2000 words **Internal Links:** - Getting Started - All key feature pages - GitHub **Publishing:** Day 12 (Friday) --- #### Week 3: Practical Guides & Authority **Post 7: Tutorial/Guide** **Title:** "Setting Up Doclea with OpenAI Embeddings vs. Local (Self-Hosted) Models" **URL:** `/blog/embedding-setup-guide/` **Meta Description:** "Compare OpenAI embeddings vs. local models for Doclea. Learn privacy implications, costs, and performance tradeoffs for code memory systems." **Keywords:** - local embedding models (10 searches/month) - openai embeddings cost (8 searches/month) - self-hosted ai models (12 searches/month) - privacy-first ai tools (15 searches/month) **Content Outline:** 1. Embedding Basics (brief) 2. OpenAI Embeddings - Pros/Cons - Cost calculation - Privacy considerations 3. Local/Self-Hosted Models - Xenova/Transformers.js option - Docker Ollama option - Setup instructions 4. Performance Comparison 5. Making the Choice 6. Step-by-step Setup (both options) **Word Count:** 2500-3000 words **Internal Links:** - Configuration page - Architecture/embeddings - Privacy documentation **Publishing:** Day 15 (Monday) --- **Post 8: Community/Social** **Title:** "How Open Source Teams Use Doclea to Accelerate Code Reviews" **URL:** `/blog/open-source-code-review/` **Meta Description:** "Case study: How open source projects use Doclea to assign reviewers automatically and reduce code review time. Includes real metrics." **Keywords:** - code review automation (10 searches/month) - open source contribution workflow (8 searches/month) - reviewer assignment tools (5 searches/month) **Content Outline:** 1. The Code Review Bottleneck in Open Source 2. Why Expertise Mapping Helps 3. Doclea Expertise Tools Overview 4. Case Study: [Real or Hypothetical Project] - Setup - Results - Before/After metrics 5. Implementing in Your Project 6. Lessons Learned **Word Count:** 1800-2200 words **Internal Links:** - Code Expertise guide - Git Integration guide - API documentation **Publishing:** Day 17 (Wednesday) --- **Post 9: Thought Leadership** **Title:** "The Future of AI Coding Assistants: Why Persistent Memory Matters" **URL:** `/blog/ai-coding-assistant-future/` **Meta Description:** "Explore how persistent memory addresses the limitations of current AI coding assistants. Building smarter, context-aware development partners." **Keywords:** - ai coding assistant features (20 searches/month) - ai development tools (25 searches/month) - context-aware ai (8 searches/month) **Content Outline:** 1. Current AI Coding Assistant Limitations 2. The Context Problem 3. Why Memory Matters 4. Persistent Memory Advantages 5. Building on Top of Memory - Team knowledge bases - Custom models - Workflows 6. The Road Ahead **Word Count:** 2000-2500 words **Internal Links:** - Getting Started - Features pages - Architecture overview **Publishing:** Day 19 (Friday) --- #### Week 4: Optimization & Engagement **Post 10: FAQ/Resource** **Title:** "Doclea FAQ: 15 Questions Developers Ask About Persistent Memory" **URL:** `/blog/doclea-faq/` **Meta Description:** "Common questions about Doclea: How does it work? Is it private? What's the cost? Can I use it with other AI tools? Comprehensive FAQ." **Keywords:** - doclea faqs (branded, builds authority) - persistent memory explained (8 searches/month) - mcp server questions (3 searches/month) **Content Outline:** 1. Getting Started Questions 2. Privacy & Security Questions 3. Performance Questions 4. Compatibility Questions 5. Cost & Pricing Questions 6. Advanced Usage Questions 7. Troubleshooting Questions **Word Count:** 2000-2500 words **Internal Links:** - Every major documentation page - Configuration - Troubleshooting **Publishing:** Day 22 (Monday) --- **Post 11: Advanced Guide** **Title:** "Advanced Doclea: Building Custom Memory Workflows for Your Team" **URL:** `/blog/advanced-memory-workflows/` **Meta Description:** "Advanced Doclea usage: Build custom memory categorization, team templates, and automated memory ingestion from your codebase." **Keywords:** - knowledge management for teams (12 searches/month) - team documentation tools (10 searches/month) - developer workflow automation (15 searches/month) **Content Outline:** 1. Beyond Basic Memories 2. Memory Categorization Strategies 3. Team Templates & Conventions 4. Automated Memory Ingestion - From git commits - From README files - From ADRs 5. Integration with Your Workflow 6. Scaling to Large Teams 7. Code Examples **Word Count:** 2500-3000 words **Internal Links:** - Memory Management guide - API Reference - Configuration - Bootstrap tools **Publishing:** Day 24 (Wednesday) --- **Post 12: Trend/Educational** **Title:** "MCP Servers for Developers: Beyond Doclea - The Ecosystem Growing Around the Model Context Protocol" **URL:** `/blog/mcp-ecosystem-overview/` **Meta Description:** "Explore the Model Context Protocol ecosystem. Doclea, file systems, web search, and other MCP servers building the future of AI-assisted development." **Keywords:** - model context protocol (8 searches/month) - mcp servers (5 searches/month) - claude tools ecosystem (3 searches/month) **Content Outline:** 1. What is the Model Context Protocol 2. Why MCP Matters 3. The MCP Ecosystem Today - Doclea (memory) - File systems - Web search - Database tools - Other emerging servers 4. Using Multiple MCP Servers Together 5. Building Your Own MCP Server 6. The Future of MCP **Word Count:** 2500-3000 words **Internal Links:** - Getting Started - Architecture overview - Contributing (if accepting MCP contributions) **Publishing:** Day 26 (Friday) --- ### 3.2 Blog Content Calendar (60-90 Days Extended) **Post 13-24 (Weeks 5-8):** 1. "Debugging with Persistent Memory: Finding Bugs Faster with Doclea" (technical) 2. "Doclea + Git Integration: Automated, AI-Written Conventional Commits" (tutorial) 3. "Privacy Deep Dive: Where Your Code Knowledge Lives with Doclea" (reassurance) 4. "Starter Template: Setting Up Doclea for a React/Node Project" (practical) 5. "Managing Technical Debt: Document Your Architecture with Doclea" (use case) 6. "Team Metrics: Measuring the Impact of Persistent Memory on Code Reviews" (metrics) 7. "Doclea vs. Context Window Tricks: Why 200K Tokens Isn't Enough" (comparison) 8. "Integrating Doclea with Your CI/CD Pipeline" (advanced) 9. "Common Doclea Mistakes and How to Avoid Them" (troubleshooting) 10. "Doclea Roadmap: What's Coming in Q1 2025" (product/news) 11. "Contributing to Doclea: Building the Memory Server Together" (community) 12. "Doclea Success Stories: Teams Using Persistent Memory in Production" (social proof) --- ## Part 4: Meta Descriptions for Key Pages ### Documentation Pages **Homepage** "Doclea: Persistent memory for Claude Code and AI coding assistants. Remember architectural decisions, patterns, and context across sessions. Works with MCP." **Getting Started** "Get started with Doclea in 30 seconds. Add to Claude Code config, initialize your project, and start storing persistent memories. No Docker required." **Memory Management** "Learn how Doclea stores and retrieves persistent memories. Semantic search, memory types (decisions, solutions, patterns), and best practices for developers." **Git Integration** "Use Doclea to auto-generate commit messages, PR descriptions, and changelogs from git history. AI-powered git workflow for faster code reviews." **Code Expertise** "Identify code owners, map expertise, and suggest PR reviewers using Doclea. Reduce bottlenecks with data-driven code review assignments." **Configuration** "Configure Doclea embedding providers (OpenAI, Ollama, Transformers), vector stores (Qdrant, SQLite), and storage backends. Full customization guide." **Architecture Overview** "Technical deep dive: How Doclea implements persistent memory with MCP protocol, embeddings, and vector search. System design for AI coding assistants." **API Reference** "Doclea API reference: Memory tools (store, search, update, delete), git tools (commits, PRs, changelogs), expertise mapping, and bootstrap utilities." **Troubleshooting** "Solutions to common Doclea issues: slow startup, SQLite errors, MCP not appearing, Docker setup problems. Complete troubleshooting guide." **FAQ** "Frequently asked questions about Doclea: How it works, privacy, cost, compatibility, setup, and advanced features. Get answers to common developer questions." --- ## Part 5: URL Structure for SEO ### Current Structure (Good) ``` https://doclea.ai/ https://doclea.ai/docs/ https://doclea.ai/docs/getting-started https://doclea.ai/docs/guides/memory-management https://doclea.ai/docs/api/overview https://doclea.ai/blog/ ``` ### Recommended Optimizations **Main Navigation Hierarchy:** ``` / (homepage) ├── /docs/ (documentation hub) │ ├── /docs/getting-started │ ├── /docs/guides/ (hub) │ │ ├── /docs/guides/memory-management │ │ ├── /docs/guides/git-integration │ │ ├── /docs/guides/code-expertise │ │ └── /docs/guides/context-building │ ├── /docs/api/ │ ├── /docs/architecture/ │ ├── /docs/configuration │ ├── /docs/troubleshooting │ └── /docs/faq ├── /blog/ (content hub) │ ├── /blog/claude-code-context-loss-problem/ │ ├── /blog/doclea-first-memory-tutorial/ │ └── [all blog posts with descriptive slugs] ├── /comparisons/ (optional new section) │ ├── /comparisons/doclea-vs-mem0/ │ └── /comparisons/doclea-vs-rag/ └── /use-cases/ (optional, or use blog) ├── /use-cases/open-source/ └── /use-cases/startup-teams/ ``` ### URL Best Practices **DO:** - Use hyphens for word separation (not underscores) - Keep URLs descriptive and keyword-relevant - Use lowercase - Keep URLs under 75 characters when possible - Use `/docs/` prefix for documentation (clear information architecture) - Use `/blog/` prefix for all blog content (separates indexed content) - Include year in blog posts only if frequently updated: `/blog/2025/doclea-faq/` **DON'T:** - Use `?utm_` parameters in canonical URLs (use on CTAs instead) - Create URL redirects unless migrating content - Use vague URLs like `/docs/guide1`, `/docs/tutorial` --- ## Part 6: Schema Markup Recommendations ### 6.1 Homepage Schema (JSON-LD) ```json { "@context": "https://schema.org", "@type": "SoftwareApplication", "name": "Doclea", "description": "Persistent memory for AI coding assistants like Claude Code", "url": "https://doclea.ai", "applicationCategory": "DeveloperApplication", "offers": { "@type": "Offer", "price": "0", "priceCurrency": "USD", "priceValidUntil": "2025-12-31" }, "featureList": [ "Persistent memory across sessions", "Semantic search", "Git integration", "Code expertise mapping", "MCP protocol support" ], "operatingSystem": "Linux, macOS, Windows", "requirements": "Node.js 18+, npm/yarn/bun", "downloadUrl": "https://www.npmjs.com/package/@doclea/mcp", "aggregateRating": { "@type": "AggregateRating", "ratingValue": "4.8", "ratingCount": "120" }, "author": { "@type": "Organization", "name": "Quantic Studios", "url": "https://quanticstudios.com" } } ``` ### 6.2 Documentation Page Schema Add to each doc page (Docusaurus front matter): ```json { "@context": "https://schema.org", "@type": "TechArticle", "headline": "[Page Title]", "description": "[Meta description]", "author": { "@type": "Organization", "name": "Quantic Studios" }, "datePublished": "2024-12-10", "dateModified": "[last update]", "image": "https://doclea.ai/img/doclea-social-card.png", "inLanguage": "en-US" } ``` ### 6.3 Blog Post Schema ```json { "@context": "https://schema.org", "@type": "BlogPosting", "headline": "[Article Title]", "image": "[Featured image URL]", "datePublished": "[ISO date]", "dateModified": "[ISO date]", "author": { "@type": "Person", "name": "[Author name]", "url": "https://doclea.ai" }, "publisher": { "@type": "Organization", "name": "Doclea", "logo": { "@type": "ImageObject", "url": "https://doclea.ai/img/logo.svg" } }, "description": "[Meta description]", "articleBody": "[Article content]" } ``` ### 6.4 Breadcrumb Schema Add to all sub-pages: ```json { "@context": "https://schema.org", "@type": "BreadcrumbList", "itemListElement": [ { "@type": "ListItem", "position": 1, "name": "Docs", "item": "https://doclea.ai/docs/" }, { "@type": "ListItem", "position": 2, "name": "Guides", "item": "https://doclea.ai/docs/guides/" }, { "@type": "ListItem", "position": 3, "name": "Memory Management", "item": "https://doclea.ai/docs/guides/memory-management" } ] } ``` ### 6.5 FAQ Schema (for FAQ page) ```json { "@context": "https://schema.org", "@type": "FAQPage", "mainEntity": [ { "@type": "Question", "name": "What is Doclea?", "acceptedAnswer": { "@type": "Answer", "text": "[Answer text]" } }, { "@type": "Question", "name": "How do I install Doclea?", "acceptedAnswer": { "@type": "Answer", "text": "[Answer text]" } } ] } ``` --- ## Part 7: Blog Content Calendar (30-60 Days) ### 30-Day Calendar | Week | Post # | Title | Keywords | Type | Word Count | Priority | |------|--------|-------|----------|------|-----------|----------| | 1 | 1 | "How Claude Code Loses Context (And Why You Need Persistent Memory)" | claude code limitations, ai context loss | Informational | 2000-2500 | HIGH | | 1 | 2 | "Your First 5 Minutes with Doclea" | how to store memories, knowledge base | Tutorial | 1500-2000 | HIGH | | 1 | 3 | "Doclea vs. Mem0 vs. DIY RAG: Which Memory System Should You Choose?" | memory systems comparison, mem0 alternative | Comparison | 2500-3500 | HIGH | | 2 | 4 | "Building a Code Knowledge Base: Semantic Search for Architecture" | semantic search code, code knowledge management | Deep Dive | 2500-3000 | MEDIUM | | 2 | 5 | "Onboarding Developers Faster with Persistent Memory" | developer onboarding, knowledge transfer | Use Case | 1800-2200 | MEDIUM | | 2 | 6 | "Announcing Doclea: MCP-Native Persistent Memory for Claude Code" | claude code tools, ai productivity tools | Product News | 1500-2000 | HIGH | | 3 | 7 | "OpenAI Embeddings vs. Local Models: Which Should You Use?" | embedding setup, privacy-first ai, self-hosted models | Tutorial | 2500-3000 | MEDIUM | | 3 | 8 | "How Open Source Teams Use Doclea to Accelerate Code Reviews" | code review automation, reviewer assignment | Case Study | 1800-2200 | LOW | | 3 | 9 | "The Future of AI Coding Assistants: Why Persistent Memory Matters" | ai coding assistant features, context-aware ai | Thought Leadership | 2000-2500 | MEDIUM | | 4 | 10 | "Doclea FAQ: 15 Questions Developers Ask" | doclea faq, persistent memory explained | FAQ/Resource | 2000-2500 | HIGH | | 4 | 11 | "Advanced Doclea: Building Custom Memory Workflows for Teams" | knowledge management, team documentation | Advanced Guide | 2500-3000 | MEDIUM | | 4 | 12 | "MCP Servers for Developers: The Ecosystem Beyond Doclea" | model context protocol, mcp servers | Educational | 2500-3000 | MEDIUM | ### Extended Calendar (60-90 Days) Continue with: - Deep dives on each major feature - Integration guides (GitHub Actions, VS Code, etc.) - Troubleshooting series - Performance optimization guides - Advanced architecture topics - Team adoption guides - Industry-specific use cases (fintech, healthcare teams, etc.) - Guest posts / interviews - Monthly product updates - Community spotlights ### Publishing Schedule **Week 1-4: 3 posts/week (high frequency to establish authority)** - Monday (8 AM UTC) - Wednesday (8 AM UTC) - Friday (8 AM UTC) **Week 5+: 2 posts/week** - Monday or Tuesday - Thursday or Friday **Promote on:** - Twitter/X (with link, key insight, CTA) - LinkedIn (developer audience) - GitHub Discussions - Dev.to (cross-post with canonical URL to doclea.ai) - Hacker News (for bigger launches) - Relevant subreddits (r/learnprogramming, r/devtools, r/git, r/Python, etc.) --- ## Part 8: On-Page SEO Checklist ### For All Pages - [ ] Unique, keyword-optimized title (50-60 characters) - [ ] Meta description (150-160 characters, primary keyword in first 80) - [ ] H1 matches or closely matches title - [ ] H2/H3 hierarchy is logical and keyword-inclusive - [ ] 100-150 words before first major heading - [ ] Internal links (3-5 contextually relevant) - [ ] External links to authoritative sources (2-4) - [ ] Image alt text (descriptive, keyword-relevant where natural) - [ ] Schema markup added (TechArticle/BlogPosting/BreadcrumbList) - [ ] URL is descriptive and under 75 characters - [ ] Readability: avg. sentence 15-20 words, avg. paragraph 3-4 sentences - [ ] Code examples when relevant (with syntax highlighting) - [ ] Word count meets target (2000+ for comprehensive authority) ### For Blog Posts Only - [ ] Introductory hook paragraph (compelling problem statement) - [ ] Table of contents generated from headings - [ ] Featured image (1200x630px, optimized) - [ ] "Published by" and "Updated on" dates visible - [ ] Reading time estimate visible - [ ] Author bio with social links - [ ] Related posts section - [ ] CTA at end (sign up, read next post, or try Doclea) - [ ] Comments/discussion enabled - [ ] Social sharing buttons visible ### For API Documentation - [ ] Parameter descriptions with type information - [ ] Return value examples (JSON) - [ ] Error handling documented - [ ] Real usage examples (copy-paste ready) - [ ] Try it out / interactive demo if possible - [ ] Version information (if applicable) - [ ] Links to relevant blog posts with same feature - [ ] Links to other related API endpoints --- ## Part 9: Technical SEO Checklist for Docusaurus ### Core Web Vitals - [ ] LCP (Largest Contentful Paint): < 2.5s - Optimize hero image size - Lazy load below-fold content - Minimize render-blocking resources - [ ] FID (First Input Delay): < 100ms - Minimize JavaScript - Defer non-critical scripts - Use Docusaurus code splitting - [ ] CLS (Cumulative Layout Shift): < 0.1 - Reserve space for images - Avoid late-loading fonts - Prevent ads/embeds from shifting layout ### XML Sitemaps - [ ] Sitemap generated and submitted to Google Search Console - [ ] Sitemap includes all docs pages and blog posts - [ ] Priority tags set appropriately: - 1.0 for homepage - 0.9 for pillar pages (getting-started, guides hub) - 0.8 for detailed guides and API pages - 0.7 for blog posts - 0.6 for archive/old content ### Robots.txt - [ ] Robots.txt allows crawling of docs and blog - [ ] Block unnecessary crawling of: - `/search/` results pages - `/api/` if external API docs - Admin or staging areas (if applicable) ### robots.txt Example: ``` User-agent: * Allow: / Disallow: /search/ Disallow: /admin/ Sitemap: https://doclea.ai/sitemap.xml ``` ### Canonical Tags - [ ] Each page has self-referential canonical tag - [ ] Blog posts specify canonical to original URL - [ ] No duplicate content issues ### Mobile Optimization - [ ] Mobile responsive (test with Mobile-Friendly Test) - [ ] Touch-friendly buttons (min 48x48px) - [ ] Readable text without zooming (16px+ base font) - [ ] No intrusive interstitials ### Page Speed - [ ] Images optimized and WebP format where supported - [ ] CSS minified - [ ] JavaScript minified and deferred where possible - [ ] Enable gzip compression - [ ] Set up CDN for static assets - [ ] Lazy load images below fold - [ ] Target Lighthouse score: 90+ ### Indexing - [ ] Google Search Console configured and verified - [ ] Google Analytics 4 configured - [ ] Initial XML sitemap submitted - [ ] Check "Coverage" report monthly for crawl errors - [ ] Check "Enhancements" report (rich results, mobile usability) --- ## Part 10: Tracking & Measurement ### Key Metrics to Track (Monthly) **Traffic Metrics:** - Organic sessions (target: 500+ by month 6) - Organic users (target: 300+ by month 6) - Bounce rate (target: < 60%) - Avg. session duration (target: > 2 min) - Pages per session (target: > 1.5) **Keyword Metrics:** - Branded keywords ranking (Doclea, @doclea/mcp, doclea ai) - Non-branded keywords ranking (MCP server, ai memory, persistent context) - Keyword ranking positions (target: top 10 for 20+ keywords by month 6) - New keyword rankings (track monthly growth) **Engagement Metrics:** - Docs page views (target: 70% of organic traffic) - Blog page views (target: 25% of organic traffic) - API reference page views - Average time on key pages (memory-mgmt, getting-started, git-integration) **Conversion Metrics:** - GitHub stars (organic source of authority) - NPM downloads (trailing indicator of adoption) - Discord/Community joins - Blog email signups (if adding newsletter) - Support tickets (shows genuine adoption) ### Tools to Set Up 1. **Google Search Console** - Monitor keyword performance - Submit sitemaps - Check coverage and enhancements - Monitor Core Web Vitals 2. **Google Analytics 4** - Track organic traffic source breakdown - Monitor user journey (landing page → docs → sign-up) - Set up goals: "visited 3+ pages", "time on site > 2 min" 3. **Ahrefs or SEMrush (Optional)** - Monthly rank tracking - Competitor content analysis - Backlink monitoring 4. **Docusaurus Analytics Plugin** - Built-in analytics integration - Monitor which docs pages drive value 5. **GitHub Stars Tracker** - Public indicator of project health - Links to SEO authority ### Reporting Template (Monthly) ``` Doclea SEO Performance - [Month Year] Traffic: - Organic Sessions: [X] (vs. [prev month], [% change]) - Organic Users: [X] - Bounce Rate: [X]% - Avg. Session Duration: [X] min Keywords (Top 10 by position): 1. [Keyword] - Position [#], Search Volume [X] 2. ... Top Pages (Organic Traffic): 1. [Page] - [X] views, [X] avg time on page 2. ... Highlights: - [Key wins from month] Next Month Focus: - [Prioritized improvements] ``` --- ## Part 11: Quick Implementation Roadmap ### Week 1: Foundation - [ ] Review and optimize homepage with schema - [ ] Replace intro.md with Doclea-specific content - [ ] Add meta descriptions to all existing pages - [ ] Create guides/ hub page - [ ] Set up Google Search Console - [ ] Submit initial XML sitemap ### Week 2: Content Creation - [ ] Create 3 new guide pages (memory, git, expertise) - [ ] Create configuration page - [ ] Create FAQ page - [ ] Publish first 3 blog posts (from calendar) ### Week 3: Architecture & Authority - [ ] Create architecture pages (overview, embeddings, vector-search) - [ ] Add schema markup to all pages - [ ] Create comparison pages (vs. Mem0, vs. RAG) - [ ] Publish next 3 blog posts ### Week 4: Optimization & Tracking - [ ] Set up GA4 and goals - [ ] Run Lighthouse audit, fix issues targeting 90+ - [ ] Optimize Core Web Vitals - [ ] Set up ahrefs/SEMrush monthly tracking - [ ] Create monthly reporting dashboard - [ ] Publish remaining blog posts ### Ongoing (Month 2+) - [ ] Continue 2 blog posts/week - [ ] Monitor GSC for new rankings - [ ] Update content based on user feedback - [ ] Build backlinks (outreach, PR mentions) - [ ] Expand internal linking as new content grows - [ ] A/B test CTAs and meta descriptions --- ## Competitive Analysis ### Current Competitors 1. **Mem0** - Positioning: Multi-agent memory, cloud-native - Keywords: memory for agents, long-term memory - Weakness: Not MCP-native, requires external service 2. **Custom RAG Solutions** - Positioning: Maximum control, DIY - Keywords: rag implementation, vector database setup - Weakness: High complexity, steep learning curve 3. **GitHub Copilot Memory** (if announced) - Positioning: Native GitHub integration - Keywords: github copilot persistent memory - Weakness: Closed ecosystem ### Doclea's SEO Advantages - MCP-native (only option for MCP users) - Zero-config setup (differentiated from DIY RAG) - Developer-first positioning (vs. enterprise Mem0) - Open source (GitHub community/authority) - Fast growth phase (new category = low competition) ### Content Strategy to Win - Own "MCP memory" + "Claude Code memory" keywords early - Build topical authority faster through blog volume - Deep technical content (embeddings, vector search) for authority - Developer education before sales pitch - Community engagement and feedback incorporation --- ## FAQ **Q: Should we focus on branded or non-branded keywords first?** A: Start with high-intent branded keywords (Doclea, @doclea/mcp) to build quick authority, then expand to non-branded (MCP server, ai memory, persistent context) as traffic grows. **Q: What's the realistic timeline for ranking?** A: - Branded keywords: 4-8 weeks - High-volume non-branded: 3-6 months - Competitive non-branded: 6-12 months Timeline assumes consistent content and proper SEO implementation. **Q: How often should we publish blog posts?** A: 3/week for first month to build authority quickly, then 2/week ongoing. Quality > Frequency, so ensure each post is 2000+ words and genuinely helpful. **Q: What if we don't have schema markup setup in Docusaurus yet?** A: Add to docusaurus.config.ts before blog launch. Docusaurus supports custom fields in front matter, making schema addition simple. **Q: Should we invest in paid search (Google Ads) alongside organic?** A: Not recommended in month 1-3. Focus on organic until you have 500+ monthly sessions. Then, use Google Ads for "doclea" branded keywords to capture high-intent traffic faster. **Q: How do we get backlinks to improve domain authority?** A: 1. GitHub press (new MCP tool = good press) 2. Product Hunt launch 3. Outreach to dev tool blogs 4. Community mentions (Dev.to, Hacker News) 5. Contributor interviews/guest posts 6. Technical podcast appearances --- ## Conclusion This SEO strategy positions Doclea to capture emerging demand in the AI coding assistant memory space. By combining: 1. **Strategic keyword targeting** (high-intent MCP/Claude Code terms) 2. **Comprehensive documentation** (establishes authority) 3. **Educational blog content** (builds community + captures problem-discovery searches) 4. **Technical depth** (differentiates from competitors) 5. **Community engagement** (drives backlinks and brand authority) Doclea can establish itself as the de facto memory solution for MCP users within 6-12 months. **Success metrics:** 5000+ monthly organic sessions, top 3 ranking for "MCP server memory" and "Claude Code memory", established GitHub authority (3000+ stars), and strong developer community participation.