{"slug": "show-hn-zerikai-memory-local-code-memory-mcp-server-now-with-jev", "title": "Show HN: Zerikai Memory: local code-memory MCP server, now with Jev", "summary": "Zerikai Memory, a local code-memory MCP server from developer KikeVen, added Jev, TypeSafe AI's System One judgment model, which scores per-passage relevance, evidence, contradiction and prompt-injection risk and returns calibrated probabilities instead of prose. Jev is off by default (ENABLE_JEV=false keeps behavior byte-identical) and is enabled by setting TYPESAFE_API_KEY and ENABLE_JEV=true in .env before restarting the server. The tool parses codebases with tree-sitter into a local ChromaDB vector store and serves context over a local STDIO MCP interface, and the maintainer develops on Windows while GitHub Actions verifies installation compiles on Windows, macOS and Linux.", "body_md": "⭐ **Bookmark the project:** If you use this tool, drop a star to save it to your GitHub profile and track new performance updates.\n\n**Never lose your AI context again.**\n\nzerikai_memory provides persistent, workspace-isolated memory for every IDE that is local-first, cost-aware, and instant. It uses deterministic Tree-Sitter code parsing indexing to capture entities and deep code descriptions like functions, classes, and docstrings into a local ChromaDB vector store. Accessed via a local MCP interface to slash token costs while maintaining high-resolution codebase mapping, it retrieves hyper-relevant context on query through L2 and Lexical re-indexing with strict source verification (Entity, File, Line Number, and L2). Designed to pair perfectly with low-cost DeepSeek APIs, it injects structured, highly precise local context instead of dumping raw, massive files, maximizing KV cache hits to radically reduce your active token costs.\n\n💡**Status: Active & Self-Contained.**\n\nThis project is used daily and actively maintained by the author. Pull Requests and Issues are closed to keep maintenance overhead low. It is provided fully functional and ready for production use.\n\n**Platform Support Notice:**\n\n**Note**: This project is developed and actively maintained on **Windows**. GitHub Actions verifies that basic installation compiles across Windows, macOS, and Linux, but the maintainer cannot troubleshoot platform-specific runtime errors on Mac or Linux. **Community pull requests fixing Mac/Linux bugs are highly welcome!**\n\nzerikai_memory now integrates **Jev**, TypeSafe AI's *System One* model — a fast, structured judgment engine that decides **which retrieved passages actually answer your question** and attaches a plain-text evidence report to every answer.\n\n- **What it is:** a second, narrow AI layer beside your LLM. Your LLM writes the answer; Jev judges the evidence it is built from. It returns calibrated probabilities — not prose.\n- **What it does:** per-passage relevance / evidence / contradiction / prompt-injection scoring, better passage ordering (replaces keyword rerank), and a plain-text`Assessment / Evidence / Guidance` report the agent can act on. Injection attempts are dropped.\n- **Off by default:** with`ENABLE_JEV=false` behavior is byte-identical to before, and it is fully fail-open — if Jev is unavailable, the normal pipeline runs.\n- **Activate it:** set`TYPESAFE_API_KEY` and`ENABLE_JEV=true` in`.env` , then restart the server.\n- **Get the API key:** TypeSafe early access →**[console.typesafe.ai](https://console.typesafe.ai)** .\n\n📖 **Full details — how the judgment layer works and every parameter:\n[documentation/10-jev-judgment-layer.md](https://github.com/KikeVen/zerikai_memory/blob/main/documentation/10-jev-judgment-layer.md)**\n\nEvery new chat session starts completely cold. When you switch contexts or open a new window:\n\n- Your AI Agent forgets every architectural decision, convention, and stack choice made over hours\n- You waste critical tokens and 10–15 minutes re-explaining the codebase setup in every single chat\n- Large raw file dumps inflate your token costs and shrink your available context window instantly\n- Switching IDEs (e.g., VS Code to Cursor) forces you to restart your conversation history from scratch\n\nZerikai Memory runs as a **local STDIO MCP server** between your IDE and your LLM. It parses your codebase using tree-sitter, indexes code entities into a local ChromaDB vector store, and injects highly relevant context snippets dynamically through natural language.\n\n```\nYour Codebase  →  tree-sitter (local parse)  →  ChromaDB (.brain/)\n                                                      │\nYour IDE       →  MCP Server (:stdio)        →        ▼\n                                             Ollama / DeepSeek\n                    │                      (auto-routed synthesis)\n          ┌─────────┴──────────────┐\n          │   4-Stage Pipeline     │\n          │   L1  Vector Search    │  ChromaDB L2 distance matching\n          │   L2  Lexical Re-rank  │  Keyword overlap boost on names\n          │   L3  Auto-Routing     │  Ollama (free) vs. DeepSeek Cloud\n          │   L4  LLM Synthesis    │  Answer + inline #file:line citations\n          └────────────────────────┘\n```\n\n| What gets taxed | Without Zerikai | With Zerikai | \n|---|---|---|\n| 🔴 **Monthly quota** | Re-explaining stack, decisions, and conventions every session | Indexed once. Retrieved as compact snippets per query. | \n| 🟡 **Context window** | Raw file dumps shrink the window available for code generation | 1,000–1,200 token brief prefix*. Window stays wide open. | \n| ⚪ **IDE switching** | Full re-explanation required in every new tool | Shared zerikai_memory workspace `.brain/` directory. | \n\n**Tip:** The project brief acts as a stable prefix. After your first query, DeepSeek caches it — making subsequent repeated queries **50–100× cheaper** (rate depends on whether you are in peak or off-peak hours). See the [DeepSeek Pricing](#deepseek-pricing) section for current rates.\n\nI have added a YouTube video walkthrough of the installation and setup process in the first step below. If you prefer text instructions, just follow along with the code snippets.\n\n## Watch the installation video\n\nClick the image below to watch a step-by-step walkthrough of the installation and setup process:\n\n```\ngit clone https://github.com/your-username/zerikai_memory.git\ncd zeriakai_memory\n\n# Create and activate a virtual environment (Python 3.11+)\npython -m venv venv\nsource venv/bin/activate  # Windows: .\\venv\\Scripts\\activate\n\npip install -r requirements.txt\n```\n\nRemove the `.example` from the `.env.example` file in the root directory and rename it to `.env`:\n\n## Expand to view .env\n\n```\nDEEPSEEK_API_KEY=your_deepseek_key_here\n\n# Memory Mode controls which LLM is used for operations:\n# - \"cloud\": Use DeepSeek for all operations (scan, brief, queries) - highest quality, tracked usage\n# - \"hybrid\": Use Ollama for file scanning, DeepSeek for briefs and escalated queries\n# - \"local\": Use Ollama for everything (free, but lower quality briefs)\nMEMORY_MODE=cloud\n\n# Enable token tracking and cost reporting (SQLite database at .brain/token_usage.db)\n# Set to \"false\" to disable tracking\nENABLE_TOKEN_TRACKING=true\n\n# Enable deepseek-v4-pro for complex architectural queries (design, architecture, tradeoffs)\n# v4-pro is ~4× more expensive than deepseek-flash. See DeepSeek Pricing section below\n# for current peak/off-peak rates.\n# Recommended: keep this \"false\" unless you need maximum reasoning capability\nENABLE_DEEPSEEK_PRO=false\n\n# DeepSeek thinking mode (chain-of-thought). Docs:\n# https://api-docs.deepseek.com/guides/thinking_mode/\n# Thinking is ON by default at effort \"high\" when no parameter is sent.\n# Options per path: enabled | disabled. \"disabled\" is right for extractive work.\n# NOTE: briefs and query synthesis are separate pipelines with separate toggles.\nDEEPSEEK_THINKING_BRIEF=disabled   # 9-section project brief generation\nDEEPSEEK_THINKING_SCAN=disabled    # per-file indexing summaries\nDEEPSEEK_THINKING_QUERY=disabled   # query_memory answer synthesis\n\n# Reasoning effort per path when that path is \"enabled\": low | high | max.\n# Ignored when the matching path is \"disabled\". \"low\" is the cheapest enabled tier.\nDEEPSEEK_REASONING_EFFORT_BRIEF=low\nDEEPSEEK_REASONING_EFFORT_SCAN=low\nDEEPSEEK_REASONING_EFFORT_QUERY=low\n\n# Semantic search relevance cutoff for query_memory (L2 distance).\n# Lower = stricter. Watch \"best dist=X.XX\" in server.log to calibrate.\n# Typical: <0.8 strong match, 0.8-1.5 related, >1.5 noise.\nQUERY_DISTANCE_THRESHOLD=1.0\n\n# File extensions to skip during scanning when tree-sitter produces zero\n# entities (no functions, classes, headings, semantic HTML elements, etc.).\n# Saves API calls on bare config files, trivial templates, empty CSS, etc.\n# Format: ['.py', '.html', '.md', '.css']\n# Default: [] (empty — no extensions skipped, all fall through to LLM).\nSKIP_BARE_FILES=['.py', '.html', '.md', '.css']\n\n# Enable lexical re-ranking in query_memory.\n# When true, results passing the distance threshold are reordered by a\n# weighted combination of semantic distance and keyword overlap in entity\n# name and docstring text. Nothing is dropped — pure reorder.\n# Default: false (existing pure-semantic behaviour preserved).\nENABLE_LEXICAL_RERANK=true\n\n# Weight applied per keyword hit during lexical re-ranking.\n# The 1/dist spread across the valid-hit band (0.85–0.98) is ~0.156.\n# Keep this value below that spread to avoid keyword hits overriding\n# a genuinely closer semantic result.\n# Recommended starting point: 0.05 (one hit = +0.05, two hits = +0.10).\nLEXICAL_RERANK_WEIGHT=0.05\n\n# Candidate pool per section for project-brief synthesis. Each section queries\n# ChromaDB, re-ranks locally, then trims to a per-section cap (20/25/30).\n# Decoupled from FETCH_CAP (query-only) so a tight query pool doesn't starve\n# the brief. Default: 20.\nBRIEF_FETCH_CAP=20\npython\npython -c \"from main import scan_workspace, query_memory; print('OK')\"\n```\n\nYou should see the startup banner followed by `OK`.\n\nTo stop your AI agent from ignoring the memory protocol, copy these directives into your IDE's agent rules profile (e.g., `.cursorrules` or system prompt guidelines):\n\n**IDE Rules in:** [agent_rules/ide_agent_rules.md](https://github.com/KikeVen/zerikai_memory/blob/main/agent_rules/ide_agent_rules.md)\n\n- **Universal-Brain First:** The agent*must* query`universal-brain` before attempting raw file searches.\n- **Source Discipline:** Every answer*must* surface actual`file.py:line` citations with zero fabrication.\n\n1. Press `Ctrl+Shift+P` →**MCP: Add Local Server**\n2. Choose **STDIO**\n3. Set command: `C:\\path\\to\\zerikai_memory\\venv\\Scripts\\python.exe C:\\path\\to\\zerikai_memory\\main.py`\n\nAdd to your `claude_desktop_config.json` profile:\n\n```\n{\n  \"mcpServers\": {\n    \"universal-brain\": {\n      \"command\": \"C:\\\\path\\\\to\\\\zerikai_memory\\\\venv\\\\Scripts\\\\python.exe\",\n      \"args\": [\"C:\\\\path\\\\to\\\\zerikai_memory\\\\main.py\"]\n    }\n  }\n}\n```\n\nWorks like `.gitignore`: one pattern per line. `scan_workspace` reads this file and skips matching paths.\n\nEach project should have its own `.memignore` in its root directory. Forgetting to configure it before the first scan is the most common reason to use `drop_memory.py` and start fresh:\n\n**Examples of what to ignore:** Expand to view\n\n## Sample .memignore\n\n```\n# Directories (trailing slash required)\n.git/\nnode_modules/\nvenv/\n__pycache__/\n.brain/\ndist/\nbuild/\n\n# File/Folder patterns\n**/test/\n**/tests/\n.env\n*.log\n*.lock\n*.pyc\n```\n\nBefore running your first index scan, optimize your codebase's docstrings for vector search. Ask your AI Agent:\n\n- To install the embedding-docstring globally in your IDE and run it against your codebase to rewrite docstrings into a more embedding-friendly format.\n  - You can find it in the [embedding-docstring skill guide](https://github.com/KikeVen/zerikai_memory/blob/main/embedding-docstring/SKILL.md) .\n- You can find it in the \n\n*\"Audit and optimize docstrings across this project using the embedding-docstring skill, respecting .memignore.\"*\n\n| Requirement | Why It Matters | Target Impact | \n|---|---|---|\n| **Explicit Tech Names** | Use `\"Uses Redis\"` instead of`\"key-value store\"` | Embeddings match precise tokens, not abstract concepts. | \n| **Routing / Branches** | Document specific route paths and logical pivot options | Ensures structural code matches are surfaceable. | \n| **Guarantees & Effects** | Explicitly state code idempotency, atomicity, or mutation side-effects | Prevents agent generation from breaking runtime boundaries. | \n\nSimply instruct your IDE's active AI agent using natural language commands:\n\nprefix queries with **\"universal-brain: <command>\"** to ensure they route through the MCP server and leverage your indexed memory:\n\n- Scan the workspace for the first time: `\"Set up memory for this project\"`\n- Ask a question: `\"What are the main architectural components of this project?\"`\n\n**Frequently used follow-ups:**\n\n- After a code change: `\"Rescan the workspace and force a refresh of the project brief.\"`\n- Save part of a chat: `\"Save the following context to memory: [your custom notes or constraints here]\"`\n- Ask how much have you used: `\"Get me a cost report for my memory usage so far.\"`\n\nSee below for a full reference of available commands and their descriptions.\n\nUpgrading zerikai_memory while keeping your already indexed workspaces is safe **as long as the workspace path never changes**.\n\nYour workspace identity is a stable UUID derived from its absolute filesystem path\n(`_derive_workspace_id` in `main.py`). Because `.brain/` is gitignored, a `git pull`\nnever touches your indexed memory, project briefs, or workspace registry.\n\n**Upgrade in place — never copy, rename, clone, or move the project directory.**\n\nThe whole point is to **preserve your already-indexed `.brain/` data** — back it up,\nupgrade the code, restore it, and you get your old memory back exactly as it was.\nNo re-indexing needed.\n\n```\n# 1. Stop the MCP server (close the IDE / kill main.py) — releases the ChromaDB lock\n\n# 2. Back up your existing indexed data so you don't lose it\n#    (do NOT rename the whole project — only back up .brain/)\n#    Windows (PowerShell):  Copy-Item -Recurse .brain .brain.bak\n#    macOS / Linux:         cp -r .brain .brain.bak\n\n# 3. Pull the latest code\ngit pull\n\n# 4. Reinstall dependencies only if requirements.txt changed\n#    Windows:  .\\venv\\Scripts\\python.exe -m pip install -r requirements.txt\n#    macOS/Linux:  venv/bin/python -m pip install -r requirements.txt\n\n# 5. Restore .brain/ (only needed if the upgrade replaced it), restart, and verify\n#    the workspace still resolves to the same UUID — your old memory is back\n```\n\n**Do NOT** rename the folder (e.g. `zerikai_memory_old`), clone into a\ndifferently-named folder, or move the project to a new parent directory. Any of\nthese changes the path → generates a new UUID → orphans your old collection and\nbrief. If you already did this, recover with `merge_workspaces`.\n\n⚠️ \n\nFull step-by-step guide, backup/restore, and recovery instructions:\n[documentation/09-upgrading.md](https://github.com/KikeVen/zerikai_memory/blob/main/documentation/09-upgrading.md)\n\nYou never run these commands directly; your active AI agent executes them on your behalf.\n\n| Tool | Description | \n|---|---|\n| `init_workspace` | Registers a project folder, assigns a UUID, and creates a pending brief file. Idempotent; safe to run multiple times. | \n| `list_workspaces` | Lists all known workspaces that have a brief or stored memories. | \n| `resolve_workspace` | Resolves a workspace identifier (UUID, short-UUID, or display name) to its filesystem path. | \n| `merge_workspaces` | Consolidates duplicate workspace IDs into one. **Irreversible.** | \n| `debug_workspace_id` | Diagnostic tool; shows what workspace ID would be generated from a given path. | \n\n| Tool | Description | \n|---|---|\n| `scan_workspace` | Starts a background scan. Returns immediately; use `scan_status` to track progress. Walks the directory, respects`.memignore` , saves all readable text files to persistent memory. Idempotent and self-cleaning. Concurrent (4 workers, batch writes). | \n| `scan_status` | Returns progress of a running or recently completed background scan: files scanned, entities indexed, errors, elapsed time, brief status. | \n| `save_to_memory` | Manually saves an architectural decision, fact, or technical note with an optional category tag. | \n| `list_memory` | Lists stored memories for a workspace, optionally filtered by category. | \n| `query_memory` | Retrieves relevant context via vector search and synthesises an answer via Ollama or DeepSeek (auto-routed). Returns the answer as plain text plus a trailing `Sources:` block of`file:line` citations with relevance scores (L2 distance or rerank). | \n| `get_brief` | Retrieves the current project brief from `.brain/contexts/` . | \n| `update_brief` | Manually updates the markdown content of a project brief. | \n\n| Tool | Description | \n|---|---|\n| `get_token_usage` | Returns DeepSeek API token usage and cost statistics. | \n| `get_cost_report` | Generates a cost breakdown by operation type. Prepends a live **PEAK / OFF-PEAK** banner showing currently active rates. | \n| `get_cache_stats` | Shows cache hit/miss rates by operation type. | \n| `purge_usage_data` | Deletes historical token tracking records. | \n\nWhen a workspace is scanned, Zerikai compiles a dense **1,000–1,200 token project brief** across 9 locked components:\n\n| Section | What It Captures | \n|---|---|\n| 1. **Overview** | Project domain, primary type, and functional scope. | \n| 2. **Technical Stack** | Backend engines, databases, integrations, and core libraries. | \n| 3. **Core Architecture** | Interactivity between frontend, backend, and processing layers. | \n| 4. **Primary Conventions** | Local code styling, custom error handling, and validation schema rules. | \n| 5. **Purpose** | Business logic problems solved and key underlying objectives. | \n| 6. **Key Files** | Definitive app entry points, central routers, and specific domain tasks. | \n| 7. **Dev & Testing** | Environment installation setups, execution triggers, and testing runs. | \n| 8. **Data Flow** | Complete systemic request lifecycle tracing from gateway to database layer. | \n| 9. **Future Roadmap** | Planned engineering steps and dangling `TODO` items parsed directly from code. | \n\nAdjust your operation profile via the `MEMORY_MODE` environment toggle to balance privacy, speed, and API costs.\n\n💡 **Deterministic First:** All high-resolution code parsing (functions, classes, methods) is performed **locally and deterministically** using Tree-Sitter for $0 cost. The engines below are only used for text-file fallbacks and generating the architectural Project Brief.\n\n| Mode | Analysis & Briefs | Query Engine | Total Cost | Ideal Use Case | \n|---|---|---|---|---|\n| 🟢 `cloud` | DeepSeek | DeepSeek | Low | **Recommended.** High-fidelity architectural briefs. | \n| 🟡 `hybrid` | Ollama | Ollama + DeepSeek | Lowest | Local privacy with cloud reasoning escalation. | \n| 🔴 `local` | Ollama | Ollama | **$0.00** | 100% air-gapped hardware-local tracking. | \n\n| Key | Default | Description | \n|---|---|---|\n| `DEEPSEEK_API_KEY` | *Required* | Active API authorization key from platform.deepseek.com. | \n| `MEMORY_MODE` | `cloud` | Sets target engines: choices include `cloud` ,`hybrid` , or`local` . | \n| `ENABLE_TOKEN_TRACKING` | `true` | Calculates continuous usage and outputs summaries to SQLite. | \n| `QUERY_DISTANCE_THRESHOLD` | `1.5` | Sets L2 vector distance cutoff limits. Lower inputs restrict matches. | \n| `ENABLE_LEXICAL_RERANK` | `false` | Activates secondary hybrid reordering layer via keyword matching. | \n| `SKIP_BARE_FILES` | `[]` | Extension list to bypass when tree-sitter finds zero valid code entities. | \n\nDeepSeek uses **peak / off-peak pricing** across all tiers. Off-peak rates are exactly half of peak rates.\n\n⏰ **Peak hours (UTC):** `01:00–04:00` and `06:00–10:00`, **Monday–Friday only**. Weekends are always off-peak.\n\n| Tier | deepseek-flash input | deepseek-flash output | deepseek-flash cached | v4-pro input | v4-pro output | v4-pro cached | \n|---|---|---|---|---|---|---|\n| **Peak** | $0.30 | $1.20 | $0.006 | $1.32 | $3.96 | $0.044 | \n| **Off-peak** | $0.15 | $0.60 | $0.003 | $0.66 | $1.98 | $0.022 | \n\nThe tool automatically resolves the correct tier at call time — no manual configuration needed.\n\n**Peak hours apply Monday–Friday only.** Weekends are always off-peak regardless of time.\nOffsets shown for **summer / daylight saving time (DST)**. In winter, US timezones shift 1 hour later; European zones shift 1 hour earlier — meaning off-peak windows shift accordingly.\n\n⚠️ \n\n| Region | UTC offset (summer) | Peak local time (Mon–Fri) | ✅ Off-peak local time | \n|---|---|---|---|\n| **EST** (New York, Miami) | UTC−5 | 8pm–11pm & 1am–5am | **5am–8pm** and 11pm–1am (+ all weekend) | \n| **CST** (Chicago, Dallas) | UTC−6 | 7pm–10pm & midnight–4am | **4am–7pm** and 10pm–midnight (+ all weekend) | \n| **PST** (Los Angeles, Seattle) | UTC−8 | 5pm–8pm & 10pm–2am | **2am–5pm** and 8pm–10pm (+ all weekend) | \n| **Ireland** (Dublin) | UTC+1 | 2am–5am & 7am–11am | **11am–2am** and 5am–7am (+ all weekend) | \n| **Spain** (Madrid) | UTC+2 | 3am–6am & 8am–noon | **noon–3am** and 6am–8am (+ all weekend) | \n| **Germany** (Berlin) | UTC+2 | 3am–6am & 8am–noon | **noon–3am** and 6am–8am (+ all weekend) | \n| **Norway** (Oslo) | UTC+2 | 3am–6am & 8am–noon | **noon–3am** and 6am–8am (+ all weekend) | \n\n**Key insight:** For US users working standard hours on weekdays, most of the working day is already off-peak (cheaper). European users in GMT+2 zones benefit from off-peak pricing through most of the afternoon and evening — and all weekend queries cost even less. Saturday and Sunday queries are always billed at off-peak rates.\n\nIf you accidentally execute a workspace crawl before setting up your `.memignore` configurations, run the auxiliary wipe script to delete stale workspace data:\n\n```\n# Windows\n.\\venv\\Scripts\\python.exe drop_memory.py \"Workspace Name\"\n\n# macOS / Linux\nvenv/bin/python drop_memory.py \"Workspace Name\"\n```\n\nMonitor server activity, runtime operations, and auto-routing logs inside **`.brain/server.log`**:\n\n```\n# Live stream logs (macOS/Linux)\ntail -f .brain/server.log\n\n# Live stream logs (Windows PowerShell)\nGet-Content .brain\\server.log -Wait -Tail 30\n```\n\n- All active vector spaces, tracking registries, and context details reside directly on your local machine.\n- Add `.env` and`.brain/` explicitly to your global or project`.gitignore` patterns to prevent API keys and secure indexes from leaking to version control platforms.\n\nTo read more about the underlying design principles, architecture decisions, and future roadmap for Zerikai Memory, check out the [insight article](https://enriquebruzual.github.io/blog/reduce-ai-ide-token-costs-with-zerikai-memory.html).\n\nMIT License © [Zerikai](http://enriquebruzual.github.io)\n\n🛠️ **Support:** This project is provided as-is for personal use.", "url": "https://wpnews.pro/news/show-hn-zerikai-memory-local-code-memory-mcp-server-now-with-jev", "canonical_source": "https://github.com/KikeVen/zerikai_memory", "published_at": "2026-09-30 13:27:55+00:00", "updated_at": "2026-09-30 13:49:51.547284+00:00", "lang": "en", "topics": ["ai-agents", "agent-protocols", "developer-tools", "ai-tools", "ai-safety"], "entities": ["Zerikai Memory", "Jev", "TypeSafe AI", "KikeVen", "ChromaDB", "tree-sitter", "DeepSeek", "Ollama"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/show-hn-zerikai-memory-local-code-memory-mcp-server-now-with-jev", "markdown": "https://wpnews.pro/news/show-hn-zerikai-memory-local-code-memory-mcp-server-now-with-jev.md", "text": "https://wpnews.pro/news/show-hn-zerikai-memory-local-code-memory-mcp-server-now-with-jev.txt", "jsonld": "https://wpnews.pro/news/show-hn-zerikai-memory-local-code-memory-mcp-server-now-with-jev.jsonld"}}