Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
Metaventions AI Research Framework — Multi-tier signal capture for frontier intelligence. Architected Intelligence.
Production-hardened API with enterprise security.
# Get JWT token
curl -X POST http://localhost:3847/api/auth/token \
-H "Content-Type: application/json" \
-d '{"client_id": "my-app", "scope": "write"}'
# Use token
curl -H "Authorization: Bearer <token>" http://localhost:3847/api/auth/me
# Or use API key
curl -H "X-API-Key: <your-api-key>" http://localhost:3847/api/v2/stats
export RG_SECRET_KEY=$(python -c "import secrets; print(secrets.token_hex(32))")
export RG_API_KEY="your-service-api-key"
export RG_LOG_LEVEL="INFO" # DEBUG, INFO, WARNING, ERROR
export RG_LOG_JSON="true" # JSON format for production
From manual workflow to intelligent auto-capture. 3x faster research sessions with real-time URL capture.
python3 scripts/session/repl.py
# Commands:
rg> start "multi-agent orchestration" # Initialize session
rg> url https://arxiv.org/... # Log URL (auto-classify)
rg> finding "Key insight about..." # Capture finding
rg> predict # Session quality prediction
rg> search "consensus algorithms" # Semantic search past sessions
rg> archive # Finalize session
python3 scripts/session/auto_capture_v2.py scan # Scan last 24 hours
python3 scripts/session/auto_capture_v2.py scan --hours 48
python3 scripts/session/auto_capture_v2.py status # Show capture stats
python3 scripts/prediction/intelligence.py predict "task" # Session quality prediction
python3 scripts/prediction/intelligence.py optimal-time # Best hour for deep work
python3 scripts/prediction/intelligence.py errors "context" # Likely errors + prevention
python3 scripts/prediction/intelligence.py patterns # Session patterns
python3 scripts/session/watcher.py daemon # Start as background daemon
python3 scripts/session/watcher.py status # Check daemon status
python3 scripts/session/watcher.py stop # Stop daemon
Priority: Qdrant → sqlite-vec → FTS fallback
- Qdrant: Full semantic search (requires server)
- sqlite-vec: Single-file vectors (offline capable)
- FTS: Full-text search fallback (always available)
Priority: Cohere v4 → Cohere v3 → SBERT offline
Cohere embed-v4.0 (default):
- Multimodal (text + images)
- 128k context window
- Matryoshka dimensions: 256, 512, 1024, 1536
Dimension Options:
- 1536d: Maximum quality
- 1024d: Balanced (default)
- 512d: 50% storage savings
- 256d: 83% storage savings
Fallback Chain:
- Cohere v4 → Cohere v3 → SBERT (all-MiniLM-L6-v2)
Auto-switches on API failure. No manual configuration needed.
The AI Second Brain is now complete. Full infrastructure for sovereign knowledge management.
┌──────────────────────────────────────────────────────────────────────────────┐
│ CHIEF OF STAFF INFRASTRUCTURE │
├──────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ CAPTURE │───▶│ STORAGE │───▶│ INTELLIGENCE│───▶│ RETRIEVAL │ │
│ │ │ │ TRIAD │ │ │ │ API │ │
│ │ Sessions │ │ │ │ Writer │ │ │ │
│ │ URLs │ │ SQLite │ │ Critic │ │ REST /api/* │ │
│ │ Findings │ │ Qdrant │ │ Oracle │ │ Graph /v2 │ │
│ │ Transcripts │ │ Graph │ │ Evidence │ │ SDK │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────────────────────┐ │
│ │ GRAPH INTELLIGENCE │ │
│ │ │ │
│ │ Sessions ──contains──▶ Findings ──cites──▶ Papers │ │
│ │ │ │ │ │ │
│ │ └──────enables─────────┴────derives_from───┘ │ │
│ │ │ │
│ │ 11,579 Nodes • 13,744 Edges • Concept Clusters • Lineage │ │
│ └────────────────────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ COGNITIVE PRECISION BRIDGE (CPB) │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Query → [Complexity Analysis] → Path Selection → Execution → DQ Score │
│ │
│ ┌──────────┬──────────┬──────────┬──────────┬──────────┐ │
│ │ DIRECT │ RLM │ ACE │ HYBRID │ CASCADE │ │
│ │ <0.2 │ 0.2-0.5 │ 0.5-0.7 │ >0.7+ │ >0.7 │ │
│ │ Simple │ Context │ Consensus│ Combined │ Full │ │
│ │ ~1s │ ~5s │ ~5s │ ~10s │ ~15s │ │
│ └──────────┴──────────┴──────────┴──────────┴──────────┘ │
│ │
│ 5-Agent ACE Ensemble: │
│ 🔬 Analyst | 🤔 Skeptic | 🔄 Synthesizer | 🛠️ Pragmatist | 🔭 Visionary │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Research-grounded answers with 95%+ quality target. Combines tiered search, grounded generation, and cutting-edge convergence research.
┌─────────────────────────────────────────────────────────────────────────┐
│ PRECISION MODE v2 PIPELINE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Query │
│ │ │
│ ▼ PHASE 1: TIERED SEARCH (ResearchGravity methodology) │
│ │ ├── Tier 1: arXiv, Labs, Industry News │
│ │ ├── Tier 2: GitHub, Benchmarks, Social │
│ │ └── Tier 3: Internal learnings (Qdrant) │
│ │ │
│ ▼ PHASE 2: CONTEXT GROUNDING │
│ │ └── Build citation-ready context (agents cite ONLY these) │
│ │ │
│ ▼ PHASE 3: GROUNDED CASCADE (7 agents) │
│ │ └── 🔬🤔🔄🛠️🔭📚💡 with citation enforcement │
│ │ │
│ ▼ PHASE 4: MAR CONSENSUS (Multi-Agent Reflexion) │
│ │ └── ValidityCritic + EvidenceCritic + ActionabilityCritic │
│ │ │
│ ▼ PHASE 5: TARGETED REFINEMENT (IMPROVE pattern) │
│ │ └── Fix weakest DQ dimension per retry │
│ │ │
│ ▼ PHASE 6: EDITORIAL FRAME │
│ │ └── Extract thesis / gap / innovation direction │
│ │ │
│ ▼ Result (DQ score + verifiable citations) │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Usage:
python3 -m cpb precision "your research question" --verbose
Traditional research workflows fail at the frontier:
ResearchGravity solves this with:
ResearchGravity/
│
├── api/ # REST API Server (v5.0+)
│ ├── server.py # FastAPI on port 3847 — 25 endpoints
│ └── routes/ # API route modules
│
├── capture/ # Event capture & normalization
├── chrome-extension/ # Browser extension for URL capture
├── cli/ # CLI Package (v6.0) — REPL commands & UI
│
├── coherence_engine/ # Cross-platform coherence detection
├── cpb/ # Cognitive Precision Bridge (v4.0)
├── critic/ # Writer-Critic validation system (v5.0)
├── dashboard/ # Web dashboard UI
├── delegation/ # Intelligent delegation (arXiv:2602.11865)
│
├── docs/ # All documentation
│ ├── context-packs/ # Context pack design & implementation docs
│ ├── meta-learning/ # Meta-learning architecture docs
│ ├── phases/ # Phase completion records
│ ├── prds/ # Product requirement documents
│ ├── routing/ # Routing workflow docs
│ └── ucw/ # UCW whitepaper & cognitive profile
│
├── graph/ # Graph Intelligence (v5.0) — 11K nodes
├── mcp_raw/ # MCP protocol & embeddings layer
├── methods/ # Research methodology definitions
├── notebooklm_mcp/ # NotebookLM MCP server (37 tools)
│
├── scripts/ # All utility scripts
│ ├── backfill/ # Backfill & migration (9 scripts)
│ ├── coherence/ # Coherence analysis pipeline
│ ├── context-packs/ # Context pack build/select/metrics
│ ├── evidence/ # Evidence extraction & validation
│ ├── importers/ # Platform importers (ChatGPT, Grok, CLI)
│ ├── prediction/ # Intelligence & prediction engine
│ ├── proof/ # Demo proof & interactive deck
│ ├── routing/ # Routing metrics & research sync
│ ├── session/ # Session management (status, init, REPL)
│ └── visual/ # Visual generation scripts
│
├── storage/ # Storage Engine — SQLite + Qdrant + sqlite-vec
├── tests/ # All test files
├── ucw/ # Universal Cognitive Wallet
├── webhook/ # Webhook event receiver
│
├── mcp_server.py # MCP server entry point
├── setup.sh # Bootstrap script
├── requirements.txt # Python dependencies
└── ruff.toml # Linter config
The Cognitive Precision Bridge provides precision-aware AI orchestration.
from cpb import cpb, analyze, score_response
# Analyze query complexity
result = analyze("Design a distributed cache system")
print(f"Complexity: {result['complexity_score']:.2f}")
print(f"Path: {result['selected_path']}")
# Build ACE consensus prompts (5 agents)
prompts = cpb.build_ace_prompts("What's the best auth strategy?")
for p in prompts:
print(f"[{p['agent']}] {p['system_prompt'][:50]}...")
# Score response quality
dq = score_response(query, response)
print(f"DQ: {dq.overall:.2f} (V:{dq.validity:.2f} S:{dq.specificity:.2f} C:{dq.correctness:.2f})")
# Analyze query complexity
python3 -m cpb.cli analyze "Your query here"
# Score a response
python3 -m cpb.cli score --query "Q" --response "R"
# View DQ statistics
python3 -m cpb.cli stats --days 30
# Check CPB status
python3 -m cpb.cli status
# Via routing-metrics
python3 scripts/routing/routing-metrics.py cpb analyze "Your query"
python3 scripts/routing/routing-metrics.py cpb status
# Clone the repository
git clone https://github.com/Dicoangelo/ResearchGravity.git
cd ResearchGravity
# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate
# Install dependencies
pip install -r requirements.txt
Create ~/.agent-core/config.json for API keys:
{
"cohere": {
"api_key": "your-cohere-api-key"
}
}
Or use environment variables:
export COHERE_API_KEY="your-cohere-api-key"
Optional (for API server):
export RG_SECRET_KEY=$(python -c "import secrets; print(secrets.token_hex(32))")
export RG_API_KEY="your-service-api-key"
python3 scripts/session/status.py
python3 scripts/session/status.py
# Basic session
python3 scripts/session/init_session.py "your research topic"
# Pre-link to implementation project (v3.1)
python3 scripts/session/init_session.py "multi-agent consensus" --impl-project os-app
# Log a Tier 1 research paper
python3 scripts/session/log_url.py https://arxiv.org/abs/2601.05918 \
--tier 1 --category research --relevance 5 --used
# Log industry news
python3 scripts/session/log_url.py https://techcrunch.com/... \
--tier 1 --category industry --relevance 4 --used
python3 scripts/session/archive_session.py
python3 scripts/session/session_tracker.py status
# Auto-detect from current directory
python3 scripts/session/project_context.py
# List all projects
python3 scripts/session/project_context.py --list
# View unified index
python3 scripts/session/project_context.py --index
1. Scan Tier 1 sources for last 24-48 hours
2. Log ALL URLs (used or not) via log_url.py
3. Tag each with: tier, category, relevance (1-5)
1. Group findings by theme (not source)
2. Identify the GAP — what's missing?
3. Draft thesis: "X is happening because Y, which means Z"
1. Write 1-paragraph summary with thesis
2. Each finding: [Name](URL) + signal + rationale
3. End with: "Innovation opportunity: ..."
Before archiving a session, verify:
When invoking ResearchGravity, always run scripts/session/status.py first:
==================================================
ResearchGravity — Metaventions AI
==================================================
📍 ACTIVE SESSION
Topic: [current topic]
URLs logged: X | Findings: Y | Thesis: Yes/No
📚 RECENT SESSIONS
1. [topic] — [date]
2. [topic] — [date]
--------------------------------------------------
OPTIONS:
→ Continue active session
→ Resume archived session
→ Start fresh
--------------------------------------------------
All research sessions are now automatically tracked. No more lost research.
Link research sessions to implementation projects:
# Pre-link at session start
python3 scripts/session/init_session.py "multi-agent DQ" --impl-project os-app
# Manual link after research
python3 scripts/session/session_tracker.py link [session-id] [project]
Recover research from old Claude sessions:
# Scan recent history
python3 scripts/session/auto_capture.py scan --hours 48
# Backfill specific session
python3 scripts/session/auto_capture.py backfill ~/.claude/projects/.../session.jsonl --topic "..."
Memory injection for Claude sessions. Automatically load relevant learnings, project memory, and research papers at session start.
# Auto-detect project from current directory
python3 scripts/session/prefetch.py
# Specific project with papers
python3 scripts/session/prefetch.py --project os-app --papers
# Filter by topic
python3 scripts/session/prefetch.py --topic multi-agent --days 30
# Copy to clipboard
python3 scripts/session/prefetch.py --project os-app --clipboard
# Inject into ~/CLAUDE.md
python3 scripts/session/prefetch.py --project os-app --inject
After sourcing ~/.claude/scripts/auto-context.sh:
prefetch # Auto-detect project, last 14 days
prefetch os-app 7 # Specific project, last 7 days
prefetch-clip # Copy context to clipboard
prefetch-inject # Inject into ~/CLAUDE.md
prefetch-topic "consensus" # Filter by topic across all sessions
backfill-learnings # Regenerate learnings.md from all sessions
Extract learnings from all archived sessions:
# Process all sessions
python3 scripts/backfill/backfill_learnings.py
# Last 7 days only
python3 scripts/backfill/backfill_learnings.py --since 7
# Specific session
python3 scripts/backfill/backfill_learnings.py --session <session-id>
# Preview without writing
python3 scripts/backfill/backfill_learnings.py --dry-run
ResearchGravity integrates with the Antigravity ecosystem:
Start the Chief of Staff API:
python api/server.py
# Running on http://127.0.0.1:3847
# Get graph stats
curl http://localhost:3847/api/v2/graph/stats | jq
# Get session subgraph
curl "http://localhost:3847/api/v2/graph/session/my-session-id?depth=2" | jq
# Find concept clusters
curl "http://localhost:3847/api/v2/graph/clusters?min_size=5" | jq
# Predict session outcome (Meta-Learning Engine)
curl -X POST http://localhost:3847/api/v2/predict/session \
-H "Content-Type: application/json" \
-d '{"intent": "implement authentication system", "track_prediction": false}' | jq
# Predict potential errors
curl -X POST http://localhost:3847/api/v2/predict/errors \
-H "Content-Type: application/json" \
-d '{"intent": "git commit and push", "include_preventable_only": true}' | jq
# Get optimal work time
curl -X POST http://localhost:3847/api/v2/predict/optimal-time \
-H "Content-Type: application/json" \
-d '{"intent": "deep architecture work"}' | jq
High-stakes outputs are validated by dual-agent critic system:
from critic import ArchiveCritic, EvidenceCritic
# Validate an archive
critic = ArchiveCritic()
result = await critic.validate("session-id")
print(f"Valid: {result.valid}, Confidence: {result.confidence:.2%}")
Query the knowledge graph:
from graph import ConceptGraph, get_research_lineage
# Get session subgraph
graph = ConceptGraph()
await graph.load()
subgraph = await graph.get_session_graph("session-id", depth=2)
d3_data = subgraph.to_d3_format() # For visualization
# Get research lineage
lineage = await get_research_lineage("session-id")
print(f"Ancestors: {len(lineage['ancestors'])}")
print(f"Descendants: {len(lineage['descendants'])}")
# Find concept clusters
clusters = await graph.get_concept_clusters(min_size=5)
MIT License — See LICENSE
Metaventions AI Dico Angelo [email protected]
Metaventions AI Research Framework — Multi-tier signal capture for frontier intelligence. Architected Intelligence.
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
ResearchGravity roda localmente via stdio.
Última verificação: 2026-10-28. Metaventions AI Research Framework — Multi-tier signal capture for frontier intelligence. Architected Intelligence.