Enovari Developer Relations & Open Source Strategy
Table of Contents
0 items1. Open Source Strategy Without Open-Sourcing Core
5 itemsPayment processing engine, fraud detection (Radar) | stripe-node, stripe-python, stripe-go, stripe-ruby, stripe-java, stripe-dotnet SDKs (6 official languages); sample apps; Stripe CLI; Stripe Shell
Communications infrastructure | Helper libraries in 7 languages (Python, Node, Java, C#, PHP, Ruby, Go); CodeExchange sample apps; Twilio CLI
GPT models, training infra | openai-python, openai-node, tiktoken, Whisper (model weights), CLIP; Cookbook repo with 200+ examples
Claude models | anthropic-sdk-python, anthropic-sdk-typescript, anthropic-cookbook; MCP specification and reference implementations
Managed Postgres hosting and optimization | supabase-js, supabase-py, supabase-flutter, Realtime server, entire Studio dashboard (React), GoTrue auth server, PostgREST
Search engine and infrastructure | InstantSearch.js, autocomplete.js, DocSearch (free for OSS docs), algoliasearch clients in 10+ languages
No successful API company open-sources their core engine to get developer adoption. They open-source the interface layer -- the code that developers actually write and modify.
The open core model keeps the proprietary platform (Enovari's memory engine, search infrastructure, persona system, API backend) closed-source while open-sourcing everything at the edges: client libraries, integrations, examples, documentation, and tooling. This is the dominant strategy used by successful API-first companies.
Tier 1 -- Open Source Immediately (GitHub public repos) Tier 2 -- Open Source Within 60 Days Tier 3 -- Open Source Within 90 Days
Memory storage engine and database schema Search/ranking algorithms (BM25+vector hybrid implementation) Persona system internals Multi-tenant isolation logic Authentication/authorization system Billing and usage metering API gateway and rate limiting The 140+ external API integration orchestration layer Training data, model weights, or any ML models Infrastructure-as-code and deployment configurations
stainlessapi.com | Custom pricing; free/discounted startup program (apply via website) | OpenAI, Anthropic, Cloudflare, Lithic | Highest quality output. Generates idiomatic SDKs in Python, TS, Go, Java, Kotlin, Ruby, C#. Also generates docs. Application required for startup program -- mention you are an AI/MCP company.
buildwithfern.com | Free tier (1 SDK), Starter $250/mo, Business custom | Cohere, ElevenLabs, Webflow, Merge | Generates SDKs + docs from OpenAPI or Fern Definition. Free tier covers one language. Also generates a docs site (Fern Docs).
speakeasy.com (formerly speakeasyapi.dev) | Free tier (2 targets), Scale $350/mo, Enterprise custom | Vercel, Airbyte, Mistral | Good TypeScript and Python output. Also generates Terraform providers. Has a GitHub Action for auto-regeneration on spec changes.
openapi-generator.tech | Free/OSS (Apache 2.0) | Community-driven | Supports 50+ languages. Quality varies significantly by language template. Python and TypeScript output often needs manual cleanup. Best as a starting point, not a final product.
liblab.com | Free tier available, paid plans for teams | Growing adoption | Newer entrant. Generates SDKs in Python, TS, Java, C#, Go. Focuses on developer experience.
Apply to Stainless's startup program first -- mention Enovari's MCP/AI memory positioning, as they prioritize AI-adjacent companies. If Stainless is not available or too slow, use Fern's free tier for the first SDK (Python), then expand. Alternatively, hand-write the initial Python and JS SDKs (the API surface is small enough) and adopt code generation when supporting 3+ languages.
1. Auto-generated from OpenAPI spec. Maintain a single OpenAPI 3.1 specification as the source of truth. Use code generation (e.g., Stainless, Fern, Speakeasy, or OpenAPI Generator) to produce consistent SDKs across languages. This is how Stripe, Anthropic, and OpenAI maintain SDK parity. 2. Idiomatic per language. Each SDK should feel native to its language. Python SDKs use dataclasses/Pydantic; JS SDKs use TypeScript types; Go SDKs use structs and interfaces. 3. Minimal dependencies. Python SDK should depend only on
httpx (or requests) and pydantic. JS SDK should depend only on node-fetch or use native fetch. Keep the dependency tree small.
4. Sync and async. Every SDK should offer both synchronous and asynchronous interfaces where the language supports it.
5. Comprehensive error handling. Typed exceptions/errors for every API error code. No generic "request failed" errors.
6. Built-in retry with backoff. Automatic retry on 429 (rate limit) and 5xx errors with exponential backoff.``
bash
# From PyPI
pip install enovari
# With optional async support (includes httpx with HTTP/2)
pip install enovari[async]
# Development install from source
git clone https://github.com/enovari/enovari-python.git
cd enovari-python
pip install -e ".[dev]"
`
`
enovari/
__init__.py # Exports Client, AsyncClient, errors
_client.py # Synchronous client implementation
_async_client.py # Async client implementation
_base_client.py # Shared HTTP logic, retry, auth
_config.py # Configuration (base URL, timeouts, retries)
types/
__init__.py
memory.py # Memory, MemoryCreate, MemorySearchResult (Pydantic models)
persona.py # Persona, PersonaConfig
organization.py # Organization
session.py # Session
shared.py # Pagination, metadata types
resources/
__init__.py
memories.py # MemoriesResource (sync + async)
personas.py # PersonasResource
organizations.py # OrganizationsResource
sessions.py # SessionsResource
errors.py # EnovariError, AuthenticationError, RateLimitError, etc.
_version.py # __version__
`
`python
import enovari
from enovari.types import MemoryCreate
# --- Basic initialization ---
# API key from parameter or ENOVARI_API_KEY environment variable
client = enovari.Client(api_key="env_...")
# --- Write a memory ---
note = client.memories.write(
topic="Project Architecture Decision",
summary="Chose PostgreSQL over MongoDB for structured memory storage",
domain="software",
subcategory="architecture",
note_type="decision",
tags=["architecture", "database", "postgresql"]
)
print(f"Memory created: {note.id} at {note.created_at}")
# --- Write with a Pydantic model (for IDE autocompletion) ---
memory_input = MemoryCreate(
topic="Sprint Retrospective",
summary="Team agreed to adopt trunk-based development starting next sprint",
domain="business",
tags=["sprint", "process"]
)
note2 = client.memories.write(**memory_input.model_dump())
# --- Search memories ---
results = client.memories.search(
query="database architecture decisions",
limit=5,
domain="software", # optional: filter by domain
tags=["architecture"], # optional: filter by tags
recall_mode="balanced" # "fast", "balanced", or "thorough"
)
for result in results:
print(f"[{result.score:.2f}] {result.topic}: {result.summary}")
# --- Read a specific memory ---
memory = client.memories.get(note_id="7926d0f1")
# --- Update a memory ---
updated = client.memories.update(
note_id="7926d0f1",
summary="Chose PostgreSQL over MongoDB -- confirmed after load testing"
)
# --- Delete a memory ---
client.memories.delete(note_id="7926d0f1")
# --- List memories with pagination ---
page = client.memories.list(limit=20, offset=0, domain="software")
print(f"Total: {page.total}, showing {len(page.items)} items")
# --- Persona operations ---
persona = client.personas.load("nexus")
print(f"Loaded persona: {persona.name}")
personas = client.personas.list()
for p in personas:
print(f" - {p.name}: {p.description}")
# --- Async usage ---
import asyncio
async def main():
async with enovari.AsyncClient(api_key="env_...") as client:
# All methods available in async form
results = await client.memories.search(query="recent tasks")
note = await client.memories.write(
topic="Async Example",
summary="This was written from async code"
)
print(f"Async write: {note.id}")
asyncio.run(main())
`
`python
import enovari
from enovari.errors import (
AuthenticationError,
RateLimitError,
NotFoundError,
ValidationError,
EnovariError,
)
client = enovari.Client(api_key="env_...")
try:
result = client.memories.search(query="test")
except AuthenticationError as e:
# 401: Invalid or expired API key
print(f"Auth failed: {e.message}")
print(f"Fix: {e.suggestion}") # "Check your API key at enovari.ai/dashboard"
except RateLimitError as e:
# 429: Rate limit exceeded (auto-retry is on by default, so this
# only fires if retries are exhausted)
print(f"Rate limited. Retry after {e.retry_after} seconds")
except NotFoundError as e:
# 404: Resource not found
print(f"Not found: {e.message}")
except ValidationError as e:
# 422: Invalid request parameters
print(f"Validation error: {e.message}")
for field_error in e.errors:
print(f" - {field_error.field}: {field_error.reason}")
except EnovariError as e:
# Catch-all for any Enovari API error
print(f"API error {e.status_code}: {e.message}")
`
`python
import enovari
# Custom configuration
client = enovari.Client(
api_key="env_...",
base_url="https://api.enovari.ai/v1", # default
timeout=30.0, # seconds, default 30
max_retries=3, # default 2
retry_on_status=[429, 500, 502, 503], # default
)
# Environment variable configuration (no code changes needed):
# ENOVARI_API_KEY=env_...
# ENOVARI_BASE_URL=https://api.enovari.ai/v1
# ENOVARI_TIMEOUT=30
# ENOVARI_MAX_RETRIES=3
client = enovari.Client() # reads from environment
````
bash
# From npm
npm install enovari
# From yarn
yarn add enovari
# From pnpm
pnpm add enovari
`
`
src/
index.ts # Exports Enovari (default), types, errors
client.ts # Main client class
resources/
memories.ts # MemoriesResource
personas.ts # PersonasResource
organizations.ts # OrganizationsResource
sessions.ts # SessionsResource
types/
index.ts
memory.ts # Memory, MemoryCreateParams, SearchParams, SearchResult
persona.ts # Persona, PersonaConfig
shared.ts # PaginatedResponse, etc.
errors.ts # EnovariError, AuthenticationError, etc.
core/
http.ts # HTTP client (native fetch, node-fetch fallback)
retry.ts # Retry logic with exponential backoff
config.ts # Configuration types and defaults
`
`typescript
import Enovari from 'enovari';
import type { Memory, SearchResult } from 'enovari';
// --- Basic initialization ---
// API key from parameter or ENOVARI_API_KEY environment variable
const client = new Enovari({ apiKey: 'env_...' });
// --- Write a memory ---
const note: Memory = await client.memories.write({
topic: 'Sprint Planning Notes',
summary: 'Decided to prioritize SDK development over dashboard features',
domain: 'business',
subcategory: 'planning',
noteType: 'decision',
tags: ['sprint', 'planning'],
});
console.log(Memory created: ${note.id} at ${note.createdAt});
// --- Search memories ---
const results: SearchResult[] = await client.memories.search({
query: 'sprint planning decisions',
limit: 5,
domain: 'business',
tags: ['planning'],
recallMode: 'balanced',
});
for (const result of results) {
console.log([${result.score.toFixed(2)}] ${result.topic}: ${result.summary});
}
// --- Read a specific memory ---
const memory = await client.memories.get('7926d0f1');
// --- Update a memory ---
const updated = await client.memories.update('7926d0f1', {
summary: 'Revised: SDK development is top priority for Q2',
});
// --- Delete a memory ---
await client.memories.delete('7926d0f1');
// --- List memories with pagination ---
const page = await client.memories.list({ limit: 20, offset: 0 });
console.log(Total: ${page.total}, showing ${page.items.length});
// --- Persona operations ---
const persona = await client.personas.load('nexus');
console.log(Loaded persona: ${persona.name});
// --- Streaming (if applicable) ---
const stream = await client.memories.search({
query: 'recent activity',
stream: true,
});
for await (const result of stream) {
console.log(result.topic);
}
`
`typescript
import Enovari, {
AuthenticationError,
RateLimitError,
NotFoundError,
ValidationError,
EnovariError,
} from 'enovari';
const client = new Enovari({ apiKey: 'env_...' });
try {
const results = await client.memories.search({ query: 'test' });
} catch (err) {
if (err instanceof AuthenticationError) {
console.error(Auth failed: ${err.message});
console.error(Fix: ${err.suggestion});
} else if (err instanceof RateLimitError) {
console.error(Rate limited. Retry after ${err.retryAfter}s);
} else if (err instanceof NotFoundError) {
console.error(Not found: ${err.message});
} else if (err instanceof ValidationError) {
console.error(Validation: ${err.message});
for (const fieldErr of err.errors) {
console.error( - ${fieldErr.field}: ${fieldErr.reason});
}
} else if (err instanceof EnovariError) {
console.error(API error ${err.statusCode}: ${err.message});
}
}
`
`html
<script type="module">
import Enovari from 'https://esm.sh/enovari';
const client = new Enovari({ apiKey: 'env_...' });
const results = await client.memories.search({ query: 'hello' });
console.log(results);
</script>
`
`typescript
const client = new Enovari({
apiKey: 'env_...',
baseURL: 'https://api.enovari.ai/v1', // default
timeout: 30_000, // milliseconds, default 30s
maxRetries: 3, // default 2
fetch: customFetch, // optional: bring your own fetch
});
// Environment variable configuration (Node.js):
// ENOVARI_API_KEY=env_...
// ENOVARI_BASE_URL=https://api.enovari.ai/v1
const client2 = new Enovari(); // reads from process.env
``github.com/enovari (or github.com/enovari-ai)README.md with badges (build status, npm/PyPI version, license)
LICENSE -- MIT for SDKs and examples, Apache 2.0 is also fine
CONTRIBUTING.md -- how to submit issues and PRs
CODE_OF_CONDUCT.md -- Contributor Covenant
.github/ISSUE_TEMPLATE/ -- bug report and feature request templates
.github/workflows/ -- CI (tests, linting, publishing)
CHANGELOG.md -- keep it updated
Branch protection on main -- require PR reviews, passing CI
One-paragraph description of Enovari
Links to docs, SDKs, examples, community Discord
"Getting Started" with 3-line code example
Badges for all published packages2. Developer Documentation
7 itemsdocusaurus.io | Free (self-hosted, MIT license) | React-based, built-in versioning, i18n (25+ locales), MDX support, search via Algolia DocSearch (free for OSS) or local search plugins, actively maintained by Meta. v3.x is latest stable. | Requires Node.js toolchain, deployment setup (Vercel/Netlify/GitHub Pages) | Full-featured doc sites with versioning needs
squidfunk.github.io/mkdocs-material | Free (open source, MIT). Material Insiders: $15+/mo (sponsor) for extra features (privacy plugin, social cards, blog) | Beautiful default theme, Python ecosystem, built-in search, Mermaid diagrams, code annotation, content tabs, admonitions. Insiders program adds social cards, meta plugin, optimize plugin. | Python-only toolchain, some best features behind sponsorship | API docs, technical docs, Python-ecosystem projects
gitbook.com | Free for personal use and small OSS teams. Pro at $8/user/month. | WYSIWYG + Markdown editor, Git sync, built-in API reference from OpenAPI, beautiful default theme, visitor authentication | Limited customization on free tier, API reference quality is decent but not best-in-class, can get pricey with team growth | Quick setup, teams with non-technical editors
readme.com | Free tier (1 project, basic features). Startup plan ~$99/mo. Business from ~$399/mo. | Interactive "Try It" API explorer, auto-generated reference from OpenAPI, metrics/analytics showing which endpoints developers use, Recipes (guided tutorials), custom landing pages | Vendor lock-in, free tier is limited (no custom domain), pricing scales steeply | API-first products that want built-in analytics
mintlify.com | Free tier (Hobby: 1 editor, custom domain, API playground). Growth from $150/mo. | Modern design, MDX, built-in API playground from OpenAPI, analytics, AI-powered search (Ask AI), auto-generated API reference, feedback widget | Newer/smaller community, vendor-hosted (you don't self-host), free tier limited to 1 editor | Startups wanting polished docs fast
fumadocs.vercel.app | Free (open source, MIT) | Next.js App Router based, MDX, OpenAPI integration, TypeScript-first, fast, built-in search | Smaller community, requires Next.js knowledge | Next.js projects, teams already using Next.js
starlight.astro.build | Free (open source, MIT) | Astro-based (fast static output), i18n, automatic navigation, good defaults, Markdown + MDX, built-in search, component overrides | Newer project, smaller plugin ecosystem than Docusaurus | Static doc sites prioritizing performance
Recommendation for Enovari: Mintlify or Docusaurus Mintlify if you want polished docs fast with minimal effort. The free Hobby tier includes a custom domain, API playground, and analytics. Many AI startups (Cursor, Resend, Mintlify themselves) use Mintlify. The built-in "Ask AI" search feature is a differentiator for developer experience. Apply for their startup credits program if available. Docusaurus if you want full control and no vendor dependency. Host on Vercel or Netlify for free. More work upfront but infinitely customizable. Pair with Algolia DocSearch (free for open-source/technical documentation) for high-quality search. > Fact-check note: Anthropic's docs (docs.anthropic.com) are custom-built, not Mintlify. Cursor's docs use Mintlify. Resend uses Mintlify. Stripe's docs are entirely custom. When claiming "Company X uses Y," verify the page source before publishing.
stripe.com/docs | Gold standard. Language tabs (7 languages), copy-paste examples with your live API key pre-filled, "Try it" sidebar, progressive disclosure, split-pane layout with prose on left and code on right | The split-pane layout. The way every endpoint shows request + response side by side. The "test mode" toggle. The breadcrumb navigation.
twilio.com/docs | Code samples in 6+ languages, quickstarts organized by use case (not by API endpoint), interactive console, "TwiML Bins" for testing. Their docs feel like a tutorial, not a reference. | Use-case-first navigation. "Send your first SMS" is the entry point, not "POST /Messages". Each quickstart is a complete working app.
docs.anthropic.com | Clean, focused, excellent prompt engineering guides with real examples, cookbook repo with Jupyter notebooks, clear rate limit documentation, versioned API reference | The prompt engineering guide structure: concept explanation, then multiple concrete examples, then anti-patterns. The "Messages API" reference is a model of clarity.
supabase.com/docs | Interactive code examples auto-generated from database schema, video walkthroughs embedded inline, framework-specific tabs (Next.js, React, Flutter, etc.) | Auto-generated client code from the user's actual database schema. Inline "Run in Supabase" buttons.
resend.com/docs | Mintlify-powered, beautiful, concise, great API reference with request/response examples, SDKs in 6 languages, clear changelogs | Brevity. Every page answers one question. No fluff. The onboarding flow from "sign up" to "send first email" is 4 steps on one page.
vercel.com/docs | Framework-aware (shows different content for Next.js vs. Nuxt vs. SvelteKit), tabbed examples, integrated with deployment, excellent error documentation | Framework detection. If you come from a Next.js project, you see Next.js examples first.
docs.pinecone.io | AI-native docs with Jupyter notebook examples, clear architecture diagrams, "Quickstart" that genuinely takes 5 minutes, organized by use case | The architecture diagrams. The "Namespaces" explanation is a model of explaining a non-obvious concept clearly.
1. Pre-filled API keys. When a logged-in developer views the docs, code examples contain their real test API key. This eliminates the "where do I put my key?" friction. 2. Split-pane layout. Left side: explanation. Right side: code + API response. Developer can read the code without scrolling away from the explanation. 3. Request log in sidebar. Stripe shows a live log of your recent API requests right in the docs sidebar. You can see if your test call worked without leaving the page. 4. Language persistence. If you select "Python," every subsequent page remembers your language choice. 5. Versioned with diff. When the API changes, Stripe shows what changed between versions. 6. Error pages are first-class. Every error code has its own page with: what caused it, how to fix it, and a working code example.
``` docs.enovari.ai/
1. Time-to-Hello-World under 5 minutes. The quickstart should go from zero to a working API call in under 5 minutes. Stripe's famous "7 lines of code" quickstart set the standard. 2. Copy-paste code that actually works. Every code snippet must be tested and runnable. Use CI to test documentation code blocks (Docusaurus supports this via
docusaurus-plugin-content-docs test integration; MkDocs supports it via mkdocs-macros-plugin or pytest-codeblocks).
3. Show, don't tell. Lead with code examples, follow with explanation. Developers skim for code blocks first.
4. Language tabs. Always show examples in Python, JavaScript, and cURL at minimum. Developers want to see their language.
5. Progressive disclosure. Start simple, reveal complexity gradually. Don't overwhelm on page one.
6. Real-world use cases in examples. Don't use foo/bar. Use realistic examples: "Store meeting notes," "Remember user preferences," "Track project decisions."
7. Error documentation. Document every error code with the cause and the fix. Developers hit errors; if they can self-serve the solution, they stay.
8. Changelog with personality. Keep a visible changelog. Developers want to know the product is actively maintained.1. "It's easy!" / "Simply do X." If it were easy, they wouldn't be reading your docs. Words like "simply," "just," and "obviously" make developers feel stupid when they struggle. Remove these words entirely. 2. Outdated code examples. Nothing destroys trust faster than a code example that doesn't work. Broken examples tell developers the product is abandoned. Test every code block in CI. 3. Auth explained on page 47. Authentication should be the first thing in the quickstart, not buried in a reference section. "How do I authenticate?" is the first question every developer asks. 4. Missing error documentation. If the API returns an error, the docs should explain it. "Contact support" is not an error message explanation. 5. No versioning. When you change the API, old docs should still be accessible. Developers on v1 shouldn't be forced to read v2 docs. 6. Walls of text with no code. Developers don't read paragraphs; they scan for code blocks. Every concept should be followed by a code example within 3-4 sentences. 7. Inconsistent terminology. If the API calls it a "note" but the docs call it a "memory," developers will be confused. Pick one term and use it everywhere. 8. No search. If developers can't Ctrl+F or search your docs, they'll use Google instead (and may end up on Stack Overflow complaints about your product). 9. PDFs. Never publish API docs as PDFs. They are unsearchable, un-linkable, and un-updatable. 10. Requiring signup to read docs. Never gate documentation behind a login. Developers evaluate products by reading docs before signing up. ``
1. What this page covers (1 sentence)
2. Prerequisites (if any)
3. Code example (working, copy-pasteable)
4. Explanation of what the code does
5. Configuration options / parameters table
6. Common errors and how to fix them
7. "Next steps" links
``scalar.com | Free/OSS (MIT) | Modern alternative to Swagger UI. Beautiful default theme, dark mode, request examples in 15+ languages. Drop-in replacement.
stoplight.io/open-source/elements | Free/OSS (Apache 2.0) | React/Web Component, embed anywhere. Reads OpenAPI spec. Good for custom doc sites.
rapidapi.com | Free tier (basic listing) | External marketplace + playground. Good for discoverability but adds a middleman.
hoppscotch.io | Free/OSS (MIT) | Self-hostable Postman alternative. Share collections via link. API testing, not docs integration.
usebruno.com | Free/OSS (MIT) | Git-friendly API client (collections stored as files in repo). Share collections with your SDK repo.
If using Mintlify, use their built-in playground. Otherwise, embed Scalar (free, modern, better-looking than Swagger UI, reads OpenAPI spec) into your Docusaurus site. Also publish a public Bruno or Postman collection in your
enovari-examples repo so developers can import and test immediately.These are mistakes that frustrate developers and generate support tickets. Avoid them from day one. 1. Inconsistent naming conventions. Bad:
/createMemory, /get_memory, /delete-memory (three different conventions)
Good: /memories (POST to create, GET to read, DELETE to remove) -- pick REST conventions and stick to them
2. Not returning the created resource.
Bad: POST /memories returns { "id": "abc123" } -- developer has to make a second request to see what was created
Good: POST /memories returns the full memory object including id, created_at, topic, summary, etc.
3. Inconsistent error format.
Bad: Sometimes { "error": "not found" }, sometimes { "message": "Not found", "code": 404 }
Good: Always return the same structure:
``json
{
"error": {
"code": "memory_not_found",
"message": "No memory found with ID 'abc123'",
"suggestion": "Check the memory ID or list all memories with GET /memories",
"request_id": "req_7f3a..."
}
}
`
4. Pagination without total counts.
Bad: Return a list with no indication of how many total items exist
Good: Return { "items": [...], "total": 142, "limit": 20, "offset": 0, "has_more": true }
5. No request IDs.
Every API response should include a unique request_id (in the response body and as an X-Request-Id header). When developers report bugs, this ID lets you find exactly what happened server-side.
6. Breaking changes without versioning.
Use URL versioning (/v1/memories) or header versioning (API-Version: 2026-04-01). Stripe uses date-based header versioning; most other APIs use URL versioning. For Enovari's size, URL versioning (/v1/) is simpler.
7. Rate limits without headers.
Always include X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers. Developers build retry logic based on these.
8. Requiring unnecessary fields.
If domain and tags are optional in the product, they should be optional in the API. Don't force developers to invent values for fields they don't need.
9. Not supporting filtering in list endpoints.
GET /memories should support ?domain=software&tags=architecture&limit=20&offset=0. Developers should never have to fetch all memories and filter client-side.
10. ISO 8601 for all dates.
Always use ISO 8601 format (2026-04-01T12:00:00Z). Never use Unix timestamps in response bodies (though accepting them as input is fine). Never use ambiguous formats like 04/01/2026`.3. Developer Advocacy Content
4 itemsPrimary: Blog on enovari.ai/blog (owned platform, SEO value) Syndicate to: Dev.to, Hashnode, Medium (reach new audiences) Frequency: 2-4 posts per month minimum
1. "The Stateless AI Problem: Why Your AI Assistant Forgets Everything" Pain point everyone experiences. High search volume for "AI memory" terms. Explain the problem, hint at the solution, link to Enovari. 2. "From Goldfish to Elephant: The Evolution of AI Memory Systems" Survey of approaches: context window stuffing, RAG, vector DBs, structured memory. Position Enovari as the structured memory layer. 3. "Why Context Windows Are Not Memory" Technical deep-dive: token limits, lost-in-the-middle problem, cost of stuffing context. Show that true memory requires persistence, search, and structure. 4. "The Coming Memory Standard: Why MCP Changes Everything for AI Agents" Tie Enovari to the MCP ecosystem. Timely given MCP adoption growth. 5. "Memory-Augmented Agents vs. RAG-Only Agents: A Benchmark" Create a simple benchmark comparing agents with/without persistent memory. Publish results, open-source the benchmark code.
6. "Build a Personal AI Assistant That Actually Remembers You (Python, 50 Lines)" Step-by-step tutorial. Minimal code. Working demo. This is the "hello world" blog post for Enovari. 7. "Add Persistent Memory to Any LangChain Agent in 10 Minutes" Target the massive LangChain developer community. Include complete code, before/after comparison. 8. "Building a Team Knowledge Base with Enovari Personas" Multi-persona setup: one persona per team member or project. Show how teams can share structured institutional knowledge. 9. "Cross-Platform AI Memory: Same Memory, Claude + GPT + Local LLM" The portability story. Write memory via Claude MCP, read it from a Python script using GPT. 10. "How I Built a Journaling App with AI Memory (Weekend Project)" Personal project storytelling. Developers love weekend project posts. Step-by-step with code. Publish the code to GitHub. 11. "Building an AI Coding Assistant with Long-Term Project Memory" Target developers building with Cursor, Copilot, Claude Code. Show how Enovari stores architectural decisions, code patterns, team conventions. 12. "Memory-Powered Customer Support Bot: Never Ask the Same Question Twice" Business use case. Shows production value.
13. "Designing a Hybrid Search System for AI Memory" High-level architecture post (without revealing proprietary details). Discuss tradeoffs of BM25 vs. vector search vs. hybrid. 14. "How We Handle Multi-Tenant Memory Isolation" Trust-building post. Developers want to know their data is safe. Discuss the principles without revealing implementation. 15. "Structured vs. Unstructured Memory: Why We Chose Both" Technical decision post. Explain the note_type system, domains, tags.
16. "Enovari + Claude Desktop: Set Up Persistent Memory in 3 Minutes" 17. "Enovari + LangChain: The Missing Memory Layer" 18. "Enovari + AutoGen: Give Your Multi-Agent System a Shared Brain" 19. "Enovari + CrewAI: Persistent Memory for AI Crews" 20. "Enovari + Raycast: AI Memory at Your Fingertips"
Series 1: "Zero to Memory" (5-part beginner series) 1. What is AI memory and why you need it 2. Your first Enovari API call 3. Organizing memories with domains, tags, and types 4. Building a memory-powered chatbot 5. Deploying your memory-powered app Series 2: "Memory Patterns" (advanced, ongoing) Memory patterns for different AI architectures Each post covers one pattern: episodic memory, semantic memory, procedural memory, working memory Include code and architecture diagrams Series 3: "Build in Public" (community engagement) Weekly posts showing what's being built at Enovari Feature previews, design decisions, lessons learned Builds trust and community connection
Record the screen while writing tutorial blog posts. Edit minimally. Publish to YouTube. This doubles the content reach with ~30 minutes extra work per post.
"Add Memory to Claude in 60 Seconds" (YouTube Short / TikTok) "5 Things Your AI Agent Forgets (And How to Fix It)" (10-min YouTube) Screen-recording tutorials for every major blog post Conference talk recordings
``
github.com/enovari/enovari-examples/
Each example should include:
README.md with what it does, prerequisites, setup steps
Working code (tested in CI)
.env.example` file
Expected output / screenshots4. Hackathons & Events
5 itemsdevpost.com | List as a "tool" or "technology" on active hackathons; sponsor a prize category; host your own hackathon (Devpost provides the submission/judging platform) | Free to list as a tool. Prize sponsorship typically $0-500 for small category. Hosting a branded hackathon starts at ~$1,000 for their platform fee. | Largest hackathon platform. Over 50,000 hackathons hosted. Most university and corporate hackathons use Devpost for submissions.
mlh.io | Partner as a "Hardware/API" sponsor for the MLH season (university hackathons globally). Provide API credits + mentorship. MLH places your logo and resources in the hackathon starter kits. | "Hardware Lab" partner: free (provide product access). Official season sponsorship tiers start at ~$5K-10K for broad reach. Individual event partnerships can be negotiated cheaper. | MLH runs 200+ hackathons per year, primarily university students. They have a "Tips & Tricks" channel in hackathon Discords where sponsors can post guides.
lablab.ai | AI-specific hackathon platform. List Enovari as an available technology/API. Mentor participants. Provide "Technology Partner" resources (docs, credits). | Free to list as a technology partner. Lablab handles the community and promotion. | Focused exclusively on AI hackathons (7-day and weekend formats). Participants tend to be more experienced with AI tools. 500K+ community members claimed.
dorahacks.io | Post bounties ("BUIDLs") for Enovari integrations. Sponsor quadratic funding rounds. Participate in their AI hackathon tracks. | Free to post bounties. You fund the prize pool directly. Minimum bounty: flexible (even $50 works). | Originally Web3-focused but has expanded to AI. Global community, strong in Asia. Good for international reach.
cerebralvalley.ai | SF-based AI community. Attend and sponsor hack nights and demo days. | Hack nights are free to attend. Sponsoring an event (food/drinks + demo slot): typically $500-2,000. | Highly influential AI builder community in San Francisco. Good for meeting potential power users and design partners.
hackathon.com | Directory of hackathons worldwide. List Enovari as a resource/API. | Free to browse and list. | Aggregator -- useful for finding hackathons to join, not for hosting.
ethglobal.com | While primarily crypto/Web3, their hackathons increasingly feature AI tracks. Sponsor as a "bounty" partner. | Bounty sponsorship: typically $2,500-10,000 for a prize category. | Very well-organized events. High-quality developers. The AI+crypto intersection is growing.
lu.ma | Not a hackathon platform per se, but many AI hackathons are organized and promoted via Lu.ma events. Monitor for "AI hackathon" events. | Free to browse. | Good for finding ad-hoc community hackathons.
June 2026 (typically SF, check ai.engineer) | Premier AI engineering event. Hackathon track. Networking with AI tool builders. | Apply as hackathon tool sponsor. Submit a talk (see Section 8). Attend even if not speaking.
Year-round (weekends, Sept-May academic season is busiest) | 200+ hackathons/year globally. University students building their first AI apps. | Apply as a Hardware Lab partner via mlh.io/partners. Free: you provide API access, they distribute your resources.
Watch anthropic.com, Anthropic Discord | As an MCP server, Enovari is a natural fit for MCP-focused hackathons. | Monitor the Anthropic Discord (#mcp channel) and blog for announcements. Reach out to Anthropic DevRel to be listed as an MCP resource.
Quarterly (announced on LangChain Discord and X/Twitter) | LangChain community hackathons. Enovari as a memory backend. | Join LangChain Discord. When hackathons are announced, offer Enovari as a resource and post a "How to use Enovari with LangChain" guide.
Ongoing (multiple per month) | Multiple AI hackathons monthly. Browse devpost.com/hackathons?themes=artificial-intelligence. | Filter by upcoming AI hackathons. Contact organizers with the email template in Section 4.5. Apply as a tool.
2-3x per year (announced on huggingface.co/blog and X/Twitter) | Open source AI community. Enovari as a complementary tool for any model. | Monitor HuggingFace blog and Discord. These tend to be online-only.
Annual (typically Q1-Q2) | Large reach (often 5,000+ participants). Enovari as a memory layer for Gemini projects. | Apply as a tool partner when the hackathon is announced on Devpost.
September 2026 (Waterloo, Canada) | Canada's biggest hackathon (1,500+ students). MLH-affiliated. | Apply as an API partner via their sponsor page. Good for brand exposure with CS students.
February 2027 (plan ahead) | Elite university hackathon. High-quality projects. | Apply early (sponsorships fill up 6+ months in advance). API partner tier is usually affordable.
1. Create a "Hackathon" API tier. Free, time-limited (30 days), generous limits (10K API calls). Auto-provision via a signup link with a hackathon-specific promo code. 2. Build a hackathon landing page.
enovari.ai/hackathon with:
One-click API key generation (no credit card, minimal form)
Quickstart code (copy-paste, language-tabbed)
3 project ideas with starter code
Link to Discord for support during the event
"Built with Enovari" badge that participants can add to their projects
3. Prepare a "Hackathon Kit" repo. github.com/enovari/hackathon-starter
Boilerplate project with Enovari pre-integrated
Choose-your-own-adventure: Python/JS, ChatBot/Agent/App
Deploy to Vercel/Railway in one click (README deploy buttons)
Include .env.example with clear instructions
Pre-built UI template (simple chat interface) so hackers can focus on the AI logic
4. Offer a bounty/prize. "Best use of Enovari Memory" -- even $50-100 in API credits or swag is meaningful at hackathons. If budget allows, offer a physical prize (e.g., mechanical keyboard, headphones) as these get more attention than credits.
5. Be present in the Discord/Slack. Answer questions in real-time during hackathons. This is the highest-ROI developer relations activity. Set up notifications for "@enovari" mentions.
6. Post-hackathon follow-up. Email all participants who signed up with:
Congratulations on their project
Offer to extend their hackathon tier for 30 more days
Invitation to the Enovari community Discord
Ask for permission to feature their project in your blog/social mediaTemplate A: General Hackathon Outreach (Email) > Subject: Enovari -- Free AI Memory API for [Hackathon Name] Participants > > Hi [Name], > > I'm [Your Name] from Enovari (enovari.ai). We provide persistent memory for AI applications -- think long-term context that survives across sessions for AI agents and chatbots. > > We'd love to offer free API access to all [Hackathon Name] participants. We can provide: > - Free API keys with generous limits (no credit card required) > - A quickstart repo with boilerplate code > - Real-time support in your event Discord/Slack > - Optional: a "Best Use of AI Memory" prize category > > Our MCP server works directly with Claude, and our REST API works with any AI framework (LangChain, LlamaIndex, AutoGen, etc.). > > Would you be interested in adding us as a tool/resource for participants? > > Best, > [Name] Template B: MLH Season Partnership Inquiry > Subject: API Partnership Inquiry -- Enovari AI Memory for MLH Hackathons > > Hi MLH Team, > > I'm [Your Name], founder of Enovari (enovari.ai). We've built a persistent memory API for AI applications -- developers use it to give AI agents and chatbots long-term, structured memory. > > We'd love to be an API partner for MLH hackathons. We can offer: > - Free hackathon-tier API keys (10K calls, 30-day access) for all participants > - A "Hackathon Starter Kit" repo with boilerplate code in Python and JavaScript > - A 3-minute video intro for hackathon opening ceremonies > - Real-time developer support in event Discord channels > - An optional "Best Use of AI Memory" prize category ($100-500 value) > > Enovari works as an MCP server (Claude integration), REST API, and through framework integrations (LangChain, LlamaIndex). It's especially relevant for AI-focused hackathon tracks. > > Could we discuss becoming a Hardware Lab / API partner for the upcoming season? > > Thanks, > [Name] > [Title], Enovari > enovari.ai Template C: Devpost Hackathon Tool Listing Request > Subject: Listing Enovari as a Tool for [Hackathon Name] on Devpost > > Hi [Organizer], > > Saw that [Hackathon Name] on Devpost includes an AI track -- great theme! > > We'd like to list Enovari (enovari.ai) as an available tool/API for participants. Enovari provides persistent memory for AI applications -- participants can use it to give their AI projects long-term context and recall. > > What we'll provide: > - Free API access for all participants (one-click signup, no credit card) > - Starter code repo: github.com/enovari/hackathon-starter > - Support channel in your Discord/Slack > - Short description + logo for the tools page > > Interested in having us participate? > > Best, > [Name] Template D: Post-Hackathon Participant Follow-Up (Email) > Subject: Your Enovari access from [Hackathon Name] -- extended! > > Hey [Name], > > Thanks for using Enovari at [Hackathon Name]! We saw some great projects come out of the event. > > Good news: we've extended your hackathon API access for another 30 days so you can keep building. > > A few things that might help: > - Full docs: docs.enovari.ai > - Example projects: github.com/enovari/enovari-examples > - Community Discord: [link] (ask questions, share what you're building) > > If you'd be open to it, we'd love to feature your hackathon project on our blog. Just reply to this email or ping us in Discord. > > Keep building, > [Name], Enovari
AI Engineer Foundation (Discord + events) LangChain Discord (regular community calls) MLOps Community (meetups + Slack) Latent Space (podcast community + events)
5. Developer Communities to Engage
4 itemsstackoverflow.com | Answer questions tagged
ai-memory, langchain, mcp, ai-agents, llm. Create canonical Q&A about AI memory patterns. | Medium | High (long-tail SEO)github.com/enovari | Enable on all repos. Be responsive. Use as primary support channel. | Low | High (retains developers)
"How to give AI agents long-term memory" "LangChain persistent memory across sessions" "How to implement memory for chatbot" "MCP server for AI memory" "AI context window too small" "How to store conversation history for LLM" "Vector database vs structured memory for AI" 1. Provide a genuine, complete answer to the question 2. Mention Enovari as one option among several, with a disclosure: "Disclosure: I work on Enovari" 3. Include working code snippets 4. Don't answer every question with Enovari -- build genuine reputation first
Discord (100K+), GitHub, Reddit |
ConversationBufferMemory doesn't persist across sessions | Enovari as a persistent memory backendFor every blog post: 1. Publish on enovari.ai/blog (canonical URL) 2. Cross-post to Dev.to with canonical URL tag (Dev.to supports this natively via the
canonical_url frontmatter field)
3. Cross-post to Hashnode with canonical URL
4. Share on X/Twitter with a code snippet screenshot
5. Share on relevant Reddit subreddits (only where genuinely helpful)
6. Share in relevant Discord servers (only where allowed)
7. Post on LinkedIn (for B2B reach)6. API-First Growth
5 itemsThe most important metric is time-to-first-successful-API-call. Every minute of friction in this path costs you developers.
``
Developer discovers Enovari (content, hackathon, word-of-mouth)
--> Signs up and gets API key (< 2 min)
--> Makes first API call (< 5 min)
--> Builds a small project
--> Integrates into production app
--> Team adopts
--> Tells other developers
--> (flywheel repeats)
``
1. Bottom-up adoption. A single developer tries the API for a side project. It works. They bring it to their team/company.
2. Integration lock-in. Once memory is integrated into an app's architecture, switching costs are high. This is healthy retention.
3. Code sharing. When developers share code on GitHub, Stack Overflow, or blog posts that includes Enovari, it becomes discoverable by others.
4. Framework integration. Being a first-class integration in LangChain/LlamaIndex means developers find you when they search for "memory" in those ecosystems.$49-99/month | 100,000 memories, 500,000 API calls/month, unlimited personas, 10 organizations | Production applications
1. No credit card required. This is non-negotiable. Requiring a credit card for free tier drops signups by 50-80%. 2. Generous enough to build something real. 1,000 memories and 5,000 API calls should be enough to build and demo a meaningful project. 3. Free forever, not free trial. Developers hate time-limited trials. The free tier should never expire. 4. Upgrade triggers should be natural. Developers upgrade when they hit limits because their project is succeeding -- this is a happy moment, not a frustration. 5. Hackathon tier. A temporary boost (30 days of Builder-level access) for hackathon participants. Easy to provision, auto-downgrades.
``
Step 1: Land on enovari.ai (0:00)
Clear headline: "Persistent Memory for AI Applications"
One CTA: "Get Your Free API Key"
Step 2: Sign up (0:30)
GitHub OAuth or email signup
No credit card
API key shown immediately on dashboard
Step 3: First API call (2:00)
Dashboard shows a "Getting Started" panel with copy-paste code
Pre-filled with user's actual API key
Three tabs: Python, JavaScript, cURL
Step 4: Success confirmation (2:30)
Dashboard shows the memory that was just written
"You just gave AI persistent memory. Now try searching for it."
Step 5: Second API call - search (3:00)
Copy-paste search query
See the memory come back in results
Step 6: "What's next?" (3:30)
Links to: MCP setup, LangChain integration, full docs, examples repo
Invite to Discord community
``[ ] API key generation takes < 30 seconds [ ] No credit card required for free tier [ ] Quickstart works in Python, JavaScript, and cURL [ ] Every code example in docs has been tested and runs [ ] Error messages are clear and actionable (include fix suggestions) [ ] Rate limit headers are included in every response (
X-RateLimit-Remaining, etc.)
[ ] API returns consistent JSON error format with error.code, error.message, error.suggestion
[ ] OpenAPI spec is published and up to date
[ ] Status page exists (use Instatus, free tier, or GitHub-based UptimeRobot)
[ ] Changelog is public and updated with every release
[ ] SDKs are published to PyPI and npm
[ ] GitHub issues are responded to within 24 hours
[ ] Discord or community channel exists for real-time support7. AI IDE & Copilot Integration Strategy
1 itemsGitHub Copilot has 1.8M+ paid subscribers (as of early 2025) and is growing rapidly. Copilot Chat and Copilot Extensions are the integration points.
A. Copilot Extension (Recommended) GitHub Copilot Extensions (GA as of late 2024) allow third-party tools to appear inside Copilot Chat. Users type
@enovari in the chat panel and can interact with Enovari memory directly from their IDE.
What to build:
A Copilot Extension that registers as @enovari
Commands: @enovari remember <topic>, @enovari recall <query>, @enovari context (fetch relevant memories for the current file/project)
The extension calls the Enovari REST API on behalf of the authenticated user
Publish to the GitHub Marketplace
```markdownUsing Enovari with GitHub Copilot
5 itemsGitHub Copilot subscription (Individual or Business) Enovari API key (free tier: enovari.ai/signup)
1. Visit github.com/marketplace/enovari-memory (or search "Enovari" in GitHub Marketplace) 2. Click "Install" and authorize for your account/organization 3. Add your Enovari API key in the extension settings
In any Copilot Chat panel (VS Code, JetBrains, GitHub.com): Store a memory:
@enovari remember We decided to use PostgreSQL for the user profile service
Recall relevant context:
@enovari recall What database decisions have we made?
Get project context for current file:
@enovari context (automatically searches for memories relevant to the open file)
List recent memories:
@enovari recentStore architecture decisions during code reviews Recall team conventions when writing new code Maintain a persistent project knowledge base that Copilot can reference ``
B. Custom Instructions / Knowledge Base Approach (No-code, immediate)
Even without a formal extension, developers can use Enovari with Copilot by:
1. Adding an .enovari or .github/copilot-instructions.md` file to their repo with project context retrieved from Enovari
2. Using a pre-commit hook or GitHub Action that syncs key project memories from Enovari into a context file that Copilot readsCursor is the fastest-growing AI IDE (500K+ users as of early 2025), and its audience is exactly the AI-enthusiast developer demographic that Enovari targets.
A. Cursor Rules + MCP (Recommended, works today) Cursor supports MCP servers natively. Since Enovari already has an MCP server, integration is straightforward. ```markdown
Using Enovari with Cursor
5 itemsCursor IDE (cursor.com, free or Pro plan) Enovari API key (free tier: enovari.ai/signup)
Cursor supports MCP servers. Add Enovari as an MCP server: 1. Open Cursor Settings > MCP 2. Add a new MCP server: Name: Enovari Memory Command: npx enovari-mcp-server Environment: ENOVARI_API_KEY=env_... 3. Restart Cursor Now in Cursor Chat (Cmd+L / Ctrl+L), you can: "Remember that we chose React Query over SWR for data fetching" "What architecture decisions have we made for the backend?" "What are the team conventions for error handling?"
Add a
.cursorrules file to your project root with instructions:
``
You have access to the Enovari memory system via MCP.
When the user makes architectural decisions, store them using ld_write.
When writing new code, check for relevant project memories using ld_read.
Key project context is in the domain "software" with tag "project-conventions".
``1. Persistent project context: Store and recall architecture decisions, coding conventions, and design rationale across Cursor sessions. 2. Team knowledge sharing: Multiple developers on the same project share an Enovari organization -- conventions stored by one developer are available to all team members in their Cursor sessions. 3. Onboarding acceleration: New team members can ask Cursor "What are the project conventions?" and get structured answers from the team's Enovari memory store. ``` B. Cursor Extension (Future) If Cursor opens a formal extension/plugin API, build a dedicated Enovari extension. Monitor cursor.com/changelog and their Discord for announcements.
Claude Code is Anthropic's CLI coding tool and natively supports MCP. Enovari already works with Claude Code via the MCP server.
```markdown
Using Enovari with Claude Code
6 itemsClaude Code supports MCP servers natively. 1. Add Enovari to your Claude Code MCP configuration: claude mcp add enovari -- npx enovari-mcp-server 2. Set your API key: export ENOVARI_API_KEY=env_... 3. Verify: run
claude and ask "What Enovari tools are available?"In any Claude Code session: "Remember that we decided to use a monorepo structure" "What technical decisions have been made for this project?" "Store this as a project convention: all API endpoints must return a request_id in the response"
When starting a new project with Claude Code + Enovari: 1. Store key architecture decisions as memories 2. Store coding conventions and style preferences 3. Store dependency choices and rationale 4. In future sessions, Claude Code automatically has access to this accumulated project context ```
enovari-vscode) that provides:Shows connected organization and memory count
Memory panel in the sidebar: browse, search, and manage memories Quick memory capture: Select code, right-click > "Save to Enovari Memory" (stores the selection with context about the file and project) Context injection: Command palette > "Enovari: Get Relevant Context" injects relevant memories as a comment block at cursor position Status bar widget: Shows connected organization and memory count Works with any AI assistant: The stored memories are accessible from Copilot, Cursor, Claude Code, or any MCP client
For the JetBrains ecosystem (IntelliJ, PyCharm, WebStorm), plan a plugin that mirrors the VS Code extension functionality. JetBrains has a large professional developer user base, especially for Python (PyCharm) and Java/Kotlin (IntelliJ).
Windsurf (by Codeium) is another AI IDE gaining traction. If it supports MCP or has an extension API, the Enovari MCP server should work out of the box. Monitor their documentation for MCP support.
8. Developer Conferences & CFPs
4 itemsJune | San Francisco | ~March | The premier AI engineering conference. This is the #1 target. | "Beyond the Context Window: Persistent Memory for AI Agents"
May | Rotating US cities | ~December (6 months ahead) | Massive Python community (3,000+ attendees). Enovari's primary SDK is Python. | "Building Memory-Powered AI Applications in Python" (tutorial or talk)
December | Rotating | ~May-June | Top ML research conference. Demo track is more accessible than paper track. | Submit to the demo track: "Enovari: Structured Persistent Memory for LLM Applications"
March (EU), November (NA) | Rotating | ~4 months ahead | Large infrastructure audience. AI infrastructure track growing. | "Stateful AI: Adding Persistent Memory to Cloud-Native AI Applications"
Multiple per year | SF, London, NYC, online | ~3-4 months ahead | Senior developers and architects. Practice-oriented. | "The Architecture of AI Memory: Lessons from Building Enovari"
Multiple per year | Various + online | ~2-3 months ahead | Data science and ML practitioners. | "Structured Memory vs. RAG: When and Why to Choose Each"
February | SF + online | Large, broad developer audience. AI track growing. | "Give Your AI Assistant a Memory: A Live Coding Session"
Various | Various | JavaScript developer community. Target the Node.js SDK. | "Persistent AI Memory in Node.js: Building Smarter AI Apps"
July | Rotating European cities | Large European Python community. | Same as PyCon angle, tailored for European audience.
Various | UK, Germany, Italy | Smaller but engaged national Python communities. Easier to get accepted. | "50 Lines of Python: Building an AI That Remembers"
October | Raleigh, NC | Open source focused. Good for the "open core" story. | "The Open Core Model: How We Open-Source SDKs While Keeping Our Engine Proprietary"
Various | Various + online | Developer relations community. Meta-talk about building DevRel. | "Building Developer Adoption for an AI API from Zero"
Submit talk proposals to these conferences. Even rejected submissions build name recognition with reviewers, and accepted talks are the highest-impact developer relations activity. Tier 1: High-Impact AI/Developer Conferences Tier 2: Developer Community Conferences Tier 3: AI-Specific Meetup-Style Conferences
Talk 1: General (30 minutes) > Title: Beyond the Context Window: Building AI Agents with Persistent Memory > > Abstract: Large language models are powerful but stateless. Every conversation starts from scratch. This talk explores how persistent, structured memory changes what AI agents can do -- from personal assistants that learn your preferences to multi-agent systems that share knowledge. We'll build a working memory-powered agent live on stage, demonstrate cross-session recall, and discuss the architectural patterns that make AI memory practical. Attendees will leave with working code and a framework for adding memory to any AI application. > > Format: 30-minute talk with live coding > Audience: AI engineers, application developers, anyone building with LLMs Talk 2: Technical Deep-Dive (45 minutes) > Title: Hybrid Search for AI Memory: BM25 + Vector at the Intersection > > Abstract: Pure vector search misses exact matches. Pure keyword search misses semantic meaning. When building a memory system for AI agents, you need both. This talk walks through the architecture of a hybrid search system designed for AI memory: how to combine BM25 and vector search, when to use each, how to rank and merge results, and the tradeoffs we discovered building a production memory platform. We'll share benchmarks comparing pure vector, pure keyword, and hybrid approaches across real-world AI memory workloads. > > Format: 45-minute technical talk > Audience: ML engineers, search engineers, AI infrastructure builders Talk 3: Tutorial Format (90 minutes) > Title: Workshop: Build an AI Agent with Long-Term Memory (Python) > > Abstract: In this hands-on workshop, participants will build a complete AI agent with persistent, structured memory. Starting from a stateless chatbot, we'll incrementally add memory capabilities: writing memories, searching by topic, organizing with domains and tags, and sharing memory across multiple agents. By the end, participants will have a working memory-powered agent and an understanding of when and why persistent memory improves AI applications. All code will be in Python, using the Enovari SDK and LangChain. > > Prerequisites: Python basics, familiarity with LLM APIs (OpenAI or Anthropic) > Format: 90-minute hands-on workshop > Audience: Python developers building AI applications Talk 4: Founder/Business Story (20 minutes) > Title: From Side Project to Developer Tool: Building an AI Memory Platform > > Abstract: This is the story of building Enovari, an API that gives AI applications persistent memory. I'll share the technical decisions (why structured memory, not just vectors), the go-to-market approach (open-core model, SDK-first), and the lessons learned from trying to convince developers they need a product they didn't know existed. Honest talk about what worked, what didn't, and what I'd do differently. > > Format: 20-minute talk > Audience: Developer tool founders, indie hackers, anyone building B2D products
1. Submit early. Many CFPs use a rolling review process. Early submissions get more attention. 2. Title matters most. Reviewers see hundreds of proposals. A specific, intriguing title beats a generic one. "Building AI Agents with Persistent Memory" beats "An Introduction to AI Memory Systems." 3. Lead with the problem, not your product. CFP reviewers reject vendor pitches. Frame the talk around the problem (stateless AI) and the patterns (persistent memory), not "come learn about Enovari." 4. Include a talk outline. A bullet-point outline of what you'll cover makes the reviewer's job easier and shows you've thought it through. 5. Live coding wins. Talks with live coding demonstrations get higher ratings. Developers want to see things built, not slides read. 6. Record a practice run. Some CFPs accept video submissions. Even if not required, including a 2-minute sample video increases your acceptance rate. 7. Apply to 10+, expect 2-3 acceptances. Conference acceptance rates are typically 10-30%. Volume matters.
9. Implementation Roadmap
4 itemsCommunity contributors submitting PRs to SDKs and examples 3+ framework integrations in official directories (LangChain, LlamaIndex, etc.) Regular hackathon presence (1-2 per month) Monthly technical blog post cadence maintained Developer newsletter launched (if audience > 500) First conference talk delivered Aim: 100+ GitHub stars, 50+ npm/PyPI weekly downloads GitHub Copilot Extension live in marketplace Cursor + Claude Code guides published and discoverable
10. Metrics & KPIs
3 itemsSet up a simple dashboard (use Notion, Google Sheets, or PostHog) tracking weekly: Signups Activated users (made first API call) API calls GitHub stars SDK downloads Blog views Community size (Discord/GitHub followers)
Appendix A: Competitive Landscape -- How Similar Products Handle Open Source
Mem0 (mem0.ai)
- Open source: Full Python SDK, server, and embedding pipeline on GitHub
- Closed: Managed platform, enterprise features
- GitHub: 25K+ stars on
mem0ai/mem0(note: verify current count before publishing -- this was ~23K in early 2025 and growing rapidly) - Takeaway: Mem0 open-sourced aggressively. Enovari doesn't need to match this -- Enovari's MCP-native approach and persona system are differentiators. Focus on SDK quality and integrations rather than open-sourcing the engine.
- Open source: Community edition of memory server (previously open core; check current model as Zep has pivoted between open-source and cloud-only strategies)
- Closed: Cloud edition with advanced features (entity extraction, knowledge graph)
- GitHub: 2.5K+ stars (verify current count)
- Takeaway: Zep has gone through model changes. Their documentation structure (organized by use case rather than API endpoint) is worth studying. Their focus on "entity extraction" and "knowledge graph" memory is a different angle than Enovari's structured note approach.
- Open source: pinecone-client (Python), pinecone-ts-client (TypeScript), Canopy RAG framework
- Closed: Vector database engine, managed infrastructure
- GitHub: Moderate stars across repos
- Takeaway: Classic API-company playbook. Never open-sourced the database. SDKs and examples only. Their docs and quickstart are worth studying.
- Open source: Full database engine (BSL license, not true OSS -- Business Source License converts to Apache 2.0 after 4 years)
- Closed: Weaviate Cloud Services (WCS), enterprise features
- Takeaway: Went further than necessary with open source. The BSL license is a strategic middle ground -- note that BSL is not OSI-approved open source. Not the model for Enovari (they had VC funding for this strategy).
- Open source: Full embedding database (Apache 2.0), Python and JS clients
- Closed: Hosted cloud service
- GitHub: 16K+ stars (verify current count)
- Takeaway: Another aggressively open-source competitor. Chroma is a vector DB, not a structured memory system, so it's more of an adjacent tool than a direct competitor. Their developer experience (especially the simple
pip install chromadblocal-first flow) is worth studying. - [ ] No "just" or "simply." Remove minimizing language. Replace "Simply run
pip install enovari" with "Runpip install enovari." - [ ] No unexplained jargon. If a term (BM25, MCP, persona) appears for the first time, link to a glossary or explain it inline.
- [ ] No broken links. Test all links in CI. Use a link checker (markdownlint, lychee, or Mintlify's built-in checker).
- [ ] No untested code. Every code block should be extracted and run in CI. Use
pytest --doctest-modulesfor Python examples or build a custom test harness. - [ ] No walls of text. If a paragraph is longer than 4 sentences, it needs a code example, a diagram, or a subheading.
- [ ] No outdated screenshots. If the UI changes, screenshots must be updated. Consider using Playwright or Puppeteer to auto-generate screenshots in CI.
- [ ] No ambiguous pronouns. "It supports this" -- what is "it"? What is "this"? Be explicit.
- [ ] No missing prerequisites. Every guide should list what the developer needs before starting (API key, Python 3.8+, Node 18+, etc.).
- [ ] No hidden authentication. The first code example on any page should show how to authenticate. Don't assume they read the auth page first.
- [ ] No version-less examples. Pin dependency versions in installation instructions.
pip install enovari>=0.1.0not justpip install enovari.
Zep (getzep.com)
Pinecone
Weaviate
Chroma (trychroma.com)
Enovari's sweet spot: Follow the Pinecone/Stripe model. Open source SDKs, examples, and integrations. Keep the memory engine proprietary. Compete on developer experience, not open source purity. The MCP-native positioning and persona system are unique differentiators that none of the above competitors offer in the same way.
Appendix B: Free Tools for Developer Relations
| Tool | Purpose | Free Tier |
| GitHub Actions | CI/CD for SDK testing and publishing | 2,000 min/month for private repos; unlimited for public repos |
| Mintlify | Documentation site | Hobby tier: free (1 editor, custom domain, API playground) |
| Vercel | Host docs site | Hobby plan: free (100GB bandwidth, serverless functions, auto-deploy from Git) |
| Netlify | Host docs site | Free tier (100GB bandwidth/month, 300 build minutes/month) |
| Instatus | Status page | Free tier (1 status page, unlimited subscribers, email notifications) |
| PostHog | Product analytics | Free tier (1M events/month, session recordings, feature flags) |
| Plausible/Umami | Privacy-friendly web analytics | Self-hosted free (both open source); Plausible cloud from EUR 9/mo; Umami cloud has free tier |
| Resend | Transactional email (onboarding emails) | Free tier (100 emails/day, 3,000 emails/month) |
| Discord | Community | Free (unlimited members, voice channels, bots) |
| Notion | Internal wiki, metrics dashboard | Free for individuals; free for small teams (limited features) |
| Canva | Social media graphics, blog images | Free tier (250,000+ templates, limited brand kit) |
| OBS Studio | Screen recording for tutorials | Free (open source, GPLv2) |
| Descript | Video editing for tutorials | Free tier (1 hour of transcription/month, watermark on exports) |
| Buffer | Social media scheduling | Free tier (3 channels, 10 scheduled posts per channel) |
| Scalar | API reference documentation | Free (open source, MIT license) |
| Bruno | API client (Git-friendly Postman alternative) | Free (open source, MIT license) |
Appendix C: Email Templates
Template 1: Framework Integration Partnership
Subject: Enovari Memory Integration for [Framework Name]
> Hi [Maintainer Name],
> I'm building Enovari (enovari.ai), a persistent memory API for AI applications. We've built an integration for [Framework] that lets developers add cross-session memory to their agents in a few lines of code.
> The integration is open source: [GitHub link]
> Would you be open to:
1. Reviewing the integration for inclusion in [Framework]'s official integrations directory?
2. A brief call to discuss how memory fits into [Framework]'s roadmap?
> We're seeing developers struggle with ephemeral agent memory, and we think [Framework] + Enovari could be a great combination.
> Thanks,
[Name]
Template 2: Conference Talk Proposal (Abstract)
Title: Beyond the Context Window: Building AI Agents with Persistent Memory
> Abstract: Large language models are powerful but stateless. Every conversation starts from scratch. This talk explores how persistent, structured memory changes what AI agents can do -- from personal assistants that learn your preferences to multi-agent systems that share knowledge. We'll build a working memory-powered agent live on stage, demonstrate cross-session recall, and discuss the architectural patterns that make AI memory practical. Attendees will leave with working code and a framework for adding memory to any AI application.
> Format: 30-minute talk with live coding
Audience: AI engineers, application developers, anyone building with LLMs
Template 3: Developer Newsletter Welcome
Subject: Welcome to the Enovari Developer Newsletter
> You're in! Every two weeks, we'll send you:
> - New tutorials and integration guides
- API updates and new features
- Community highlights (cool things developers are building)
- AI memory tips and patterns
> To get started with Enovari right now:
- https://enovari.ai/signup" target="_blank" rel="noopener">Get your free API key
- https://docs.enovari.ai/quickstart" target="_blank" rel="noopener">5-minute quickstart
- https://discord.gg/enovari" target="_blank" rel="noopener">Join our Discord
> See you around,
The Enovari Team
Appendix D: "Show HN" Post Template
Title: Show HN: Enovari -- Persistent Memory API for AI Agents (MCP + REST)
> Hey HN,
> I've been building Enovari (https://enovari.ai), an API that gives AI applications persistent, structured memory.
> The problem: LLMs are stateless. Every conversation starts from zero. Developers hack around this with context stuffing, but that's expensive, limited, and brittle.
> What Enovari does: Provides a memory layer that AI agents can write to and search. Memories are structured (topics, domains, tags, types), searchable (hybrid BM25 + vector), and portable across AI platforms.
> What's open source:
- Python SDK: github.com/enovari/enovari-python
- JS/TS SDK: github.com/enovari/enovari-js
- MCP Server: github.com/enovari/enovari-mcp-server
- Examples: github.com/enovari/enovari-examples
> Free tier: 1,000 memories, 5,000 API calls/month, no credit card required.
> Quick example (Python):
python
import enovari
client = enovari.Client(api_key="env_...")
client.memories.write(topic="Architecture Decision", summary="Chose Postgres for structured memory")
results = client.memories.search(query="database decisions")
> Works as an MCP server (plug into Claude), REST API (plug into anything), or through our framework integrations (LangChain, LlamaIndex, etc.).
> Would love feedback on the API design and docs. Happy to answer questions about the architecture.
Appendix E: Documentation Anti-Patterns Checklist
Before publishing any documentation page, verify it does not contain these anti-patterns:
Document version: 2.0 Last updated: April 2026 Related goal: VOLTEST-19 (100 users Q2 2026) Changelog: v2.0 -- Added detailed SDK designs (Python + JS), AI IDE integration strategy (Copilot/Cursor/Claude Code), conference CFP guide, expanded hackathon section with outreach templates, documentation best practices, API design anti-patterns, documentation anti-patterns checklist. Fact-checked platform names, pricing, and feature claims.