convez.ai
MCP ServerProdutividadeAvançado
trip2g

trip2g - Malha de Conhecimento Descentralizada com MCP

trip2g/trip2g

Segunda mente descentralizada para agentes e humanos

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server open-source que transforma sua base de conhecimento em um servidor vivo: auto-hospedável, acessível via Protocol de Contexto do Modelo (MCP) para agentes de IA, e federável com pares. Suporta wikilinks, busca híbrida, webhooks para automações e monetização nativa. Diferente de plataformas SaaS, você controla onde seus dados vivem.

Instalação

$npx convez-ai trip2g/trip2g

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
41
Forks
2
Acompanhando
0
Saúde
50%
Último commit
há 1 dia
Versão
v0.12.0
Issues abertas
29
Contribuidores
1

Casos de uso

  • Compartilhar base de conhecimento entre múltiplos agentes de IA
  • Criar rede federada de bases conectadas com peers
  • Auto-hospedar e monetizar conteúdo privado/público
  • Sincronia bidirecional entre notas e agentes via webhooks
  • Busca semântica + full-text em conhecimento distribuído

Veredito

Trip2g reinventa o conceito de second brain como protocolo federar, não plataforma. Para quem quer auto-hospedar conhecimento robusto e expô-lo a agentes IA com controle total—arquitetura sólida em Go, MCP nativo, e economia de tokens bem pensada.

README

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

trip2g

License: MIT Go

Open-source MCP knowledge mesh. Self-host your knowledge bases, expose them to AI agents via MCP, and federate with peers — no SaaS in the middle.

Unlike Obsidian Publish or Quartz, trip2g is a live server: subscriptions, webhook agents, federation between hubs, and an MCP endpoint out of the box.

Try the public hub → · Self-host · Docs

trip2g landing


Second brain network for your agents

A second brain isn't one person's vault — it's the shared knowledge of people who think about the same things.

Each person runs a hub with their own notes. Agents reach into it directly via MCP. Hubs peer with each other, so one question fans out across the network — your bases plus the ones your trusted peers share with you.

   human A           human B           human C
      │                 │                 │
      ▼                 ▼                 ▼
   agent A           agent B           agent C
      │                 │                 │
      ▼                 ▼                 ▼
  ┌────────┐  MCP  ┌────────┐  MCP  ┌────────┐
  │ hub A  │ ◄───► │ hub B  │ ◄───► │ hub C  │
  └────────┘       └────────┘       └────────┘
       ▲                 ▲                 ▲
       └─── humans browse · agents query ──┘

Same hub serves the human (a website with subscriptions, RSS, Telegram) and the agent (MCP). Data lives where you put it. trip2g is a protocol, not a vendor.


Try it now

Add the public knowledge hub to your MCP client:

{
  "mcpServers": {
    "trip2g": {
      "url": "https://trip2g.com/_system/mcp"
    }
  }
}

Ask your agent anything. It searches all connected bases and returns answers with sources.

Want your own? Free cloud instance — no terminal needed.


Core capabilities

Markdown → website

  • Wikilinks ([[note]]), backlinks, outlinks — global resolution, just like Obsidian
  • Composable page layouts via frontmatter: sidebars, magazine grid, TOC, custom note embeds
  • Hybrid search: bleve full-text + OpenAI embeddings, merged via reciprocal rank fusion
  • Custom domains, multi-language with hreflang, RSS output, sitemap

MCP server — built into every hub:

ToolPurpose
searchHybrid full-text + semantic search
note_htmlRead a note (or a section) by id, path, or match
similarNotes similar to a given note
federated_search / federated_similar / federated_note_htmlSame, fanned out to peer hubs
instructionsAuthor-defined prompt for the agent

Access is scoped to the caller's subscription. Custom tools can be defined in note frontmatter (mcp_method:).

Webhook agents

  • Change webhooks — POST to an external agent on note create/update/remove. Agent writes notes back via API. Glob filtering, HMAC auth, depth tracking prevents recursion.
  • Cron webhooks — run an agent on a schedule (0 9 * * *). Sync or async. Optional instruction context.

Monetization

  • Subgraph paywalls — group notes into paid products, free notes stay public
  • Crypto payments (NowPayments), Patreon and Boosty integration

Obsidian plugin — one-click sync, hash-based diff, only changed files are uploaded.


Federation

graph LR
    O[Obsidian vault] --> H[your hub]
    T[Telegram]       --> H
    H <-->|MCP federation| H2[peer hub]
    H2 --> B[their bases]
    H -->|/_system/mcp| A[agent]
    H2 -->|/_system/mcp| A

Peer hubs with trusted people or orgs. Each hub controls access per base. One agent question reaches the union of all connected knowledge.

TopologySetupResult
SoloOne hub, many basesAll your notes, books, courses — one query
FriendsEach person runs a hub, hubs peerUnion of everyone's knowledge
CompanyCentral hub + per-employee hubsTribal knowledge and docs — queryable
B2BTwo star topologies, one bridgeShared knowledge without merging systems

Sources

SourceStatus
Obsidianready — vault stays local, two-way sync
Telegramready — channel publish + history mirror
RSS outputready — every base exposes feeds
Notionplanned
Google Driveplanned
Linear, Slack archive, RSS importplanned

Template system

Two paths — pick one per knowledge base.

A. Default template (no code, frontmatter-only). Built-in trip2g layout. Compose pages from widgets and content blocks via frontmatter:

---
header: "[[Navigation]]"
left_sidebar: [TOC, inlinks]
content: [selfcontent, magazine]
magazine_include_files: "blog/**/*.md"
footer: "[[Footer]]"
---

Rendered through quicktemplate. Notes can also render as HTML, JSON, RSS via content_type frontmatter.

B. Custom Jet templates (full control). Drop your own .html files into a layouts folder and switch via layout: path/to/template. Templates have access to the markdown AST — iterate sections, render specific parts, customize layout down to HTML. Built on the Jet template engine.


Self-host

docker compose up

Full guide → · MIT · SQLite, no external dependencies required.


Tech stack

BackendGo, FastHTTP, gqlgen (GraphQL)
DatabaseSQLite + Litestream for streaming backup
Searchbleve (full-text) + OpenAI embeddings (semantic)
MarkdownGoldmark — wikilinks, frontmatter
Templatesquicktemplate (default) + Jet (custom)
Frontend$mol, TypeScript, Tiptap
AssetsS3-compatible (MinIO for dev)

License

MIT

Ver o original no GitHub

Bom para

Relacionados