convez.ai
MCP ServerAutomaçãoAvançado
tdries

Veritype: Verificador de Fatos Nativo do Slack

tdries/dev-slackathon-agent

Fact-checker nativo do Slack com cartões visuais de veredicto em segundos

Ver no GitHub
InicialPluginScore · de 0 a 100

Um agente MCP que monitora mensagens no Slack, identifica afirmações verificáveis e oferece fact-checking com um clique, retornando um cartão de veredicto visual com gráficos de confiabilidade de fontes, distribuição de suporte/refutação e tendências. Usa Claude, busca web e renderiza resultados em imagens via Puppeteer com a fonte variable Datatype para visualizações em tempo real.

Instalação

$npx convez-ai tdries/dev-slackathon-agent

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
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 4 dias
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Validar claims e estatísticas compartilhadas em canais corporativos
  • Reduzir desinformação em tempo real dentro de fluxos de trabalho em equipe
  • Documentar fontes e confiabilidade de informações de forma visual e acessível

Veredito

Projeto técnico sofisticado que combina IA generativa, busca web e renderização visual para resolver um problema real de desinformação corporativa. A implementação é complexa (TypeScript, Puppeteer, variable fonts, Block Kit), adequada para times que dominam ecossistema Slack e querem automação inteligente nativa.

README

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


Table of contents

  1. Project description
  2. Components / tech used
  3. Agent type declaration
  4. Setup instructions
  5. What it looks like

1. Project description

Slack is where modern teams trade information at high speed, and high-speed information is also how half-true claims spread. Someone drops a stat in #general, three people emoji-react, and by the afternoon it is treated as fact. Veritype closes that loop, in-channel, in seconds.

Veritype is a Slack-native fact-checking agent. It quietly listens to channels it has been invited to, runs a fast claim-classifier over each message, and when it spots a verifiable, public-interest claim it offers (privately to the speaker, no public noise) "want me to fact-check that?" One tap fires a research agent that fans out web searches, weighs sources, and replies in thread with a verdict card.

That verdict card is the bit that nobody else does. Veritype renders it through the Datatype OpenType variable font. Datatype turns plain-text expressions like {b:20,45,70,82} into real bar charts via ligature substitution. We use that to give every verdict three inline charts the team can read at a glance:

  • {b:…}: a bar chart of source-quality weights (primary docs first, blogs last).
  • {p:…}: a stack of pie charts for the support / refute / context breakdown.
  • {l:…}: a sparkline for how the claim's salience has trended over time.

The whole card is rendered headlessly in Puppeteer and posted to Slack as an image attachment, with a Block Kit mrkdwn fallback for screen readers, search, and threads on the mobile client.

TodayWith Veritype
Claim drops in channel, no one challenges itBot offers a 1-tap fact-check, privately
Person who pushes back has to Google for ten minutesVerdict arrives in 5 to 8 seconds with weighted citations
"Source?" reply derails the thread for the rest of the dayCard stays in thread, sources are one click away, channel stays calm
The team's track record on disputed claims is invisibleWorkspace dashboard tracks claims, verdicts, latency, channel coverage

Why this fits Slack Agent Builder Challenge

We hit two of the three required platform pillars:

  • MCP server integration: Veritype's fact-check brain is exposed as a Model Context Protocol server (src/mcp/server.ts). The Slack bot is one client of it. Any other MCP-aware client (Claude Desktop, IDE extensions, agent frameworks) can call the same three tools.
  • Real-Time Search API: The researcher agent uses Anthropic's web_search_20250305 tool to pull and read live sources. We never invent citations.

Track: New Slack Agent, with the Most Innovative and Best UX awards in mind.

2. Components / tech used

ComponentRolePath
Slack Bolt appSocket-mode app, slash command /veritype, message listener, button handlerssrc/slack/app.ts
Slack Block Kit blocksVerdict block layout, mrkdwn fallback, action buttonssrc/slack/blocks.ts
Claim screener (Haiku)Triage layer that decides whether a message contains a verifiable claimsrc/core/screener.ts
Researcher (Opus + web_search)Web-search-grounded research agent that produces the verdict, confidence, and weighted sourcessrc/core/researcher.ts
Datatype card templatePrint-perfect HTML card with Datatype font embedded for inline bar / pie / sparkline chartssrc/core/cardTemplate.ts
Puppeteer card rendererRasterizes the HTML card to a PNG suitable for posting to Slacksrc/core/renderer.ts
MCP serverExposes screen_message, verify_claim, and render_verdict_card over stdio MCPsrc/mcp/server.ts
React / Vite dashboardWorkspace home, library, playground, MCP info, settings: all in a Slack-skinned UI for demo/screenshotssrc/web/
Datatype font (Apache 2.0)The variable font that makes {b:…} / {l:…} / {p:…} render as inline chartsassets/fonts/ · public/fonts/
Sample fixturesThree pre-baked reports (mostly_true, false, misleading) used by the playground and CLI renderersrc/core/sample.ts

3. Agent type declaration

Veritype is built as a Coded Agent. Everything is TypeScript: the claim screener, the research loop, the renderer, the Slack handlers, the MCP server. There is no no-code component.

The agent runs a two-model pipeline:

  • claude-haiku-4-5: fast, cheap classifier that screens every channel message.
  • claude-opus-4-7: research-grade synthesizer with web_search_20250305 enabled and a JSON output contract, with claude-sonnet-4-6 as fallback.

The MCP server (src/mcp/server.ts) exposes the same brain to any other MCP client, so a teammate in Claude Desktop can call verify_claim and get the identical, source-weighted answer the Slack bot would deliver.

4. Setup instructions

Prerequisites

  • Node.js 20+
  • An Anthropic API key with access to Claude Opus 4.7 + the web_search_20250305 tool
  • A Slack app in your workspace with Socket Mode enabled (instructions below)

1. Clone and install

git clone https://github.com/<your-org>/veritype.git
cd veritype
npm install

2. Configure environment

cp .env.example .env

Fill in:

  • ANTHROPIC_API_KEY: your Anthropic key.
  • SLACK_BOT_TOKEN: xoxb-… from your Slack app's OAuth & Permissions page.
  • SLACK_APP_TOKEN: xapp-… from your app's Basic Information → App-Level Tokens, with the connections:write scope.
  • SLACK_SIGNING_SECRET: your app's signing secret (Basic Information → App Credentials).

3. Create the Slack app

Full click-by-click walkthrough lives in docs/SLACK-SETUP.md. TL;DR:

  1. Go to api.slack.com/apps → Create New App → From a manifest and paste docs/slack-app-manifest.yaml.
  2. Generate an app-level token (xapp-...) with connections:write scope.
  3. Install the app to your workspace, grab the bot token (xoxb-...).
  4. Paste all four tokens into .env, then run npm run setup:check to validate.

4. Run locally

# in one terminal
npm run dev:slack    # starts the Bolt app in Socket Mode

# in another terminal (optional, for the dashboard / screenshots)
npm run dev:web      # Vite dev server on http://127.0.0.1:5173

Type /veritype Iceland runs on 100% renewable electricity in any channel the bot is a member of. Within ~6 seconds the verdict card lands in thread.

5. Use as an MCP server (optional)

Build once, then point any MCP client at the bundle:

npm run build:slack   # compiles src/ → dist/

In ~/.claude/claude_desktop_config.json (or any MCP client config):

{
  "mcpServers": {
    "veritype": {
      "command": "node",
      "args": ["/absolute/path/to/veritype/dist/mcp/server.js"],
      "env": { "ANTHROPIC_API_KEY": "sk-ant-..." }
    }
  }
}

The three exposed tools are screen_message, verify_claim, and render_verdict_card.

6. Render a sample card without Slack

npm run render:card -- mostly_true
# wrote docs/screenshots/sample-mostly_true.png

This is the fastest way to confirm the font, Puppeteer, and template are working before touching the Slack side.

5. What it looks like

Try the live demo

npm install
npm run dev:web      # opens at http://127.0.0.1:5173/?tab=stream

The channel stream tab is fully interactive. Type a message in the composer (or tap one of the preset claims) and Veritype actually screens it, offers an ephemeral verification, then posts a verdict card. With no ANTHROPIC_API_KEY set, the demo runs in fixture mode (still real Slack UX, deterministic verdicts). Set the key and the same flow goes live: real Haiku 4.5 screener, real Opus 4.7 + web_search research.

In-channel: the proactive offer

Veritype screens each new message through Haiku 4.5. When it spots a verifiable, public-interest claim, it posts an ephemeral "want me to verify this?" only the message author can see, with the screener's confidence score for transparency.

Slack channel with the proactive offer

One tap, verdict in thread

Click "Verify this claim" and the agent fans out, weighs sources, and replies in thread with the Datatype-rendered card. Real time. Real sources. Real verdict.

Full verdict card delivered in the Slack thread

The verdict card

One tap, a few seconds, and the bot replies in thread with a verdict card. The pill at the top shows the verdict and a confidence pie. Three metrics below give source-weight bars, an evidence balance (supports / refutes / context as three inline pies), and a salience sparkline. Every source is rated, dated, stance-tagged, and links to the original.

Veritype verdict card for a mostly-true claim

The same template handles every verdict level: here is a false claim with a red accent and a support/refute mix dominated by refutation:

Veritype verdict card for a false claim

Workspace home

Open the Veritype app in Slack to see the workspace home. KPIs at the top track claims verified, true/false share, and median latency, all rendered with Datatype charts. Below: verdict mix, latency over time, channel coverage, and recent verifications.

Veritype workspace home in Slack

Verification library

Every claim Veritype has fact-checked, across every channel, with full citations. Filter by channel, person, verdict, or just full-text search. Click a card to open the full verdict.

Verification library

Card playground

Tweak any field in a sample report and watch the Datatype card update live. This is the same template the bot ships into Slack threads: handy for visually testing edge cases before shipping to production.

Card playground with live preview

MCP server

The fact-check brain is also an MCP server. Drop the config into Claude Desktop and the same three tools the Slack bot calls become available to your local Claude.

MCP server page

Settings

Per-workspace tuning: auto-listen toggle, channel allow-list regex, claim threshold, model choice, web-search budget, and verdict formatting.

Veritype settings


Repo layout

src/
  core/           shared brain (screener, researcher, renderer, types, samples)
  slack/          Bolt app + Block Kit blocks
  mcp/            stdio MCP server wrapping the same core
  web/            Vite + React dashboard (Slack-skinned, used for demos and screenshots)
assets/
  fonts/          Datatype woff2 (Regular / Medium / SemiBold / Bold): Apache 2.0
docs/
  screenshots/    in-app screenshots, sample verdict cards
  manual/         operator manual sources + rendered PDF
deck/             pitch deck (.pptx + .pdf)

License

MIT for the code in this repo. The Datatype font (assets/fonts/) is Apache 2.0; see franktisellano/datatype for the source.

Ver o original no GitHub

Bom para

Relacionados