convez.ai
MCP ServerBusca & PesquisaIntermediário
conjfrnk

Memovox

conjfrnk/memovox

Converta vídeos em memória pesquisável com respostas citadas

Ver no GitHub
InicialPluginScore · de 0 a 100

Motor local-first que transforma vídeos em conhecimento consultável. Processe palestras, podcasts, reuniões e entrevistas para buscar informações e fazer perguntas em linguagem natural, obtendo respostas com citações precisas (vídeo, timestamp e quem falou). Roda 100% offline, sem APIs ou chaves externas.

Instalação

$npx convez-ai conjfrnk/memovox

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
71%
Último commit
há 4 meses
Versão
v0.1.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Indexar e buscar em palestras, cursos online e tutoriais
  • Processar gravações de reuniões e calls para encontrar decisões e contexto
  • Analisar entrevistas e podcasts sem precisar reassistir
  • Comparar narrativas e mudanças de posição em múltiplos vídeos

Veredito

Ferramenta sólida para quem trabalha com muito conteúdo em vídeo e precisa extrair informação sem depender de serviços na nuvem. Abordagem local-first com upgrades opcionais é pragmática; documentação clara e design honesto (admite o que não faz no core grátis) inspiram confiança.

README

A tradução para o português deste README ainda está na fila.

memovox

license: AGPL-3.0 commercial license available python: 3.9+ local-first: no API keys

memovox turns videos into a searchable memory you can ask questions of. Point it at a talk, lecture, meeting, interview, or podcast, then ask plain-English questions later. Every answer comes with a citation — which video, the exact moment (one click jumps you there), and who said it. The one rule it never breaks: if it can't cite where it learned something, it won't claim it.

New here? Start with the plain-language overview: What is memovox? →

Heads up: memovox runs in the terminal — there's no clickable app yet. (It also has a Python library, a REST server, and an MCP server for wiring into AI assistants.)

What it's good for

Anything you'd rather not re-watch — a lecture or podcast, or a meeting, interview, or Zoom/Teams call you recorded yourself: find what was said (and shown) across long recordings, and get answers you can verify. Across many videos it can also summarize a topic, surface where sources disagree, and trace how an idea changed over time. It works on any recording with speech — the subject matter doesn't matter.

Free, private, and local-first

Hand memovox a transcript and the whole thing runs offline on your machine — no account, no API key, nothing uploaded. Your videos, transcripts, and answers never leave your computer. The core needs only the Python standard library. Want higher quality? Drop in optional, still-local upgrades (better transcription, smarter search, a local language model) with no change to how you use it. Each model upgrade downloads its weights the first time you use it, then runs locally; the optional local language model runs on Ollama (a free app for running AI models on your own computer) that you set up yourself.

StepFree — always worksOptional local upgrade
Speech → text (ASR)use a transcript you already have (VTT/SRT)transcribe audio yourself: faster-whisper ([asr])
Get the video inlocal file or transcriptdownload from a URL: yt-dlp ([acquire])
Search by meaning (embeddings)built-in deterministic hashingsentence-transformers BGE-M3 ([embed])
Fact-check each claim (NLI)built-in lexical entailmentDeBERTa-NLI ([nli])
Write the answer (LLM)built-in rule-based + extractive answersa local model via Ollama (run an Ollama server — no pip extra)
Read on-screen text & describe visualsnot in the free corethe tesseract program (on-screen text) + a local Ollama vision model (describe visuals)
Store & searchone SQLite file (full-text + vectors + links)LanceDB / Kùzu

The fully-free path needs a transcript (most sites, including YouTube, let you download one). To transcribe raw audio or read what's on screen, add the matching upgrade above.

Free answers are concise and quoted straight from the source; add the embedding upgrade for sharper search and a language model to rewrite the quotes into a single, natural-language answer. Run memovox backends to see what's active, and swap any piece with --asr / --embed / --nli / --llm.

Install

pip install -e .                 # core only — stdlib, runs immediately
pip install -e ".[asr,embed]"    # add offline Whisper + dense embeddings
pip install -e ".[acquire]"      # add yt-dlp URL ingestion

ffmpeg/ffprobe are recommended (demux + validation), but transcripts ingest without them. Or run without installing: python -m memovox --help.

Quick start

# Ingest a transcript with no models at all (fully free):
memovox ingest ~/talks/scaling-laws.en.vtt --source-url https://youtu.be/abc123

# Ingest from a URL ([acquire] extra). Audio-only by default; add --with-video to also
# analyze the picture (keyframes are free; reading on-screen text needs the tesseract program):
memovox ingest https://youtu.be/abc123 --with-video

# Ask a grounded question — every answer sentence carries a citation:
memovox ask "what chunk size did they recommend, and who said it?"

# Cross-corpus synthesis (run consolidate after ingesting new sources):
memovox consolidate
memovox synthesize "scaling laws"
memovox contradictions --topic "scaling laws"
memovox evolution --entity "Chinchilla"

memovox list        # what's ingested
memovox backends    # which optional upgrades are active
memovox stats       # store summary

The Python SDK, REST, and MCP sections below are for developers building on memovox — if you just want cited answers, the commands above are all you need.

Python SDK

from memovox import Memovox

mv = Memovox(store="~/knowledge")
mv.ingest("~/talks/scaling-laws.en.vtt", source_url="https://youtu.be/abc123")
ans = mv.ask("what's the recommended chunk size, and who recommended it?")
print(ans.text)
for c in ans.citations:
    print(c.video_id, c.t_start_s, c.deep_link)

MCP server

memovox mcp     # speaks MCP over stdio — wire into Claude Code / Desktop

Stdlib-only (no mcp package required); tools: ingest_video, search_knowledge, list_videos, get_claim_provenance, synthesize_topic, find_contradictions, claim_timeline, consolidate, job_status.

Once connected you don't have to ask for memovox by name — the server ships model-facing instructions, so "watch this video and tell me what it says about X" routes to ingest_video → job_status → search_knowledge on its own. For Claude Desktop, add to claude_desktop_config.json:

{
  "mcpServers": {
    "memovox": { "command": "memovox", "args": ["mcp"] }
  }
}

(Claude Desktop launches servers with a minimal PATH — if it can't find the command, use the absolute path from which memovox.)

REST server

memovox serve              # HTTP API on 127.0.0.1:8808 — stdlib, no extra needed
memovox serve --fastapi    # use FastAPI/uvicorn instead (pip install -e ".[serve]")

How it's different (under the hood)

A local-first, multimodal video-to-knowledge engine — meaning in, cited memory out.

Most "chat with your video" tools are transcript-only RAG (retrieval-augmented generation): they pull captions, chop them into chunks, embed them, and hand the closest matches to a chatbot. Two costs: the chatbot can confidently state things that aren't in the video, and everything you see — slides, charts, code — is thrown away.

memovox ingests at the level of meaning and guarantees that every assertion resolves to a specific source, time span, modality (spoken vs. shown), and confidence — in code, (video, [t_start, t_end], modality, confidence). If it can't say where it learned something, it doesn't claim it.

Pipeline

You never need these names to use memovox — this is the internal flow, for developers:

source ─▶ Stentor (acquire · demux · ASR · diarize)
   └─▶ Tessera (keyframes · OCR · VLM)
        └─▶ Escapement (temporal fusion → Moments)
             └─▶ Assay (claim extraction → NLI gate → typing)
                  └─▶ Loom (vector + lexical + graph indices · synthesis)
                       └─▶ Augur (plan → hybrid retrieve → cited answer)
                            └─▶ CLI · Python SDK · REST · MCP

ASR = speech-to-text · NLI = the fact-checking (entailment) step · OCR = reading text in images · VLM = a vision model that describes frames.

Design principles

  • Provenance is sacred — every fact resolves to a timestamped, modality-tagged span.
  • Verify before commit — claims are entailment-checked against their source first.
  • Idempotent ingestion — content-hash IDs; re-ingesting merges, never duplicates.
  • Model-agnostic, local-first — swappable backends; a fully offline default.
  • Human-readable substrate — Markdown digests over a SQLite DB you can inspect.

Development

make test                                    # stdlib unittest (no pytest required)
make lint                                    # ruff, if installed
python -m eval.harness --assert-thresholds   # golden-corpus quality gates

For design background, see docs/DESIGN.md (how the pieces map to the code) and spec.md (the full specification). Contributing: CONTRIBUTING.md (note the DCO + CLA). Security: SECURITY.md. How quality is measured: docs/BENCHMARK.md.

License

memovox is dual-licensed:

  • Open source: AGPL-3.0-or-later — free to use, modify, and self-host. Note the AGPL's network copyleft: if you run a modified memovox as a network service, you must offer your users its source (AGPL §13).
  • Commercial: if the AGPL doesn't fit (e.g. embedding in a proprietary product, or running a hosted service without sharing your changes), a commercial license is available — see COMMERCIAL-LICENSE.md.

Copyright (C) 2026 Connor.

Ver o original no GitHub

Bom para

Relacionados