convez.ai
AgenteSegurançaAvançado
jayapasam9-max

Assistente Autônomo de Review de Código

jayapasam9-max/Agentic-AI-Assistant

Review automático de PRs com Claude, detecta riscos e comenta inline

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent que analisa automaticamente pull requests no GitHub, detecta problemas de segurança e performance, e comenta inline nas mudanças. Orquestrado com Claude, LangChain4j, Kafka e PostgreSQL com pgvector, inclui dashboard React em tempo real.

Instalação

$npx convez-ai jayapasam9-max/Agentic-AI-Assistant

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
1
Acompanhando
0
Saúde
57%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Automação de code review em repositórios Java
  • Detecção contínua de vulnerabilidades de segurança
  • Análise de performance de mudanças de código
  • Monitoramento em tempo real com dashboard operacional

Veredito

Projeto robusto e production-ready que integra Claude para review semântico profundo com observabilidade operacional. Escolha natural para times que precisam escalar análise de código mantendo qualidade, apesar da curva de aprendizado Java/Spring.

README

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

Agentic Code Review Assistant

Java Spring Boot LangChain4j Claude Kafka PostgreSQL pgvector TypeScript React Vite Tailwind TanStack Query Vercel Render Docker License

An autonomous code review agent that analyzes GitHub pull requests, flags security and performance issues, and posts inline comments — backed by Claude, LangChain4j, Kafka, and Postgres with pgvector.

Live demo

Open the operator dashboard →

Operator dashboard — Metrics view

React + TypeScript dashboard that watches the agent run in real time. Reviews list, live token-by-token reasoning stream over Server-Sent Events, and a metrics view of daily volume, token usage, and estimated cost. Built with Vite, Tailwind, and TanStack Query; deployed on Vercel Hobby and talking to the Spring Boot backend on Render. $0/month end-to-end. Build plan in PHASE_5_DASHBOARDS.md.

Architecture at a glance

flowchart LR
    PR["GitHub PR<br/>(opened / synced)"] -->|webhook| Backend["Spring Boot<br/>+ LangChain4j"]
    Backend -->|tool calls| Claude["Claude<br/>(Anthropic API)"]
    Claude -->|findings| Backend
    Backend -->|inline comments| PR
    Backend -->|reads / writes| DB[("Postgres<br/>+ pgvector")]
    Backend -->|SSE + JSON| UI["React dashboard<br/>(Vercel)"]

Webhook in → agent runs the Claude tool-use loop → findings persisted to Postgres and posted back to the PR as inline comments → React dashboard reads aggregates over JSON and subscribes to live events over SSE.

Repository layout

.
├── backend/                  Spring Boot + LangChain4j agent service
│   ├── pom.xml
│   └── src/main/java/com/codereview/agent/
│       ├── agent/            Agent orchestrator + LangChain4j AI service
│       │   ├── CodeReviewerAgent.java
│       │   ├── ReviewOrchestrator.java
│       │   └── tools/        @Tool-annotated methods for Claude to call
│       ├── config/           Spring config (beans, properties, Kafka, LangChain4j)
│       ├── github/           Webhook controller + GitHub API client
│       ├── kafka/            Kafka consumers + event records
│       ├── sse/              Server-Sent Events controller for the live dashboard
│       └── persistence/      JPA entities + repositories
├── prompts/
│   └── system_prompt.md      The core reviewer prompt (the highest-leverage file)
├── infra/                    Terraform for VPC, EKS, RDS, MSK, ECR, observability
│   ├── main.tf
│   └── modules/{vpc,eks,rds,msk,ecr,observability}/
├── docker-compose.yml        Local dev stack (Postgres+pgvector, Kafka)
└── README.md

Screenshots

Operator dashboard

Metrics — daily review volume, token usage, and estimated cost: Operator dashboard — Metrics view

Inline PR comments

Hardcoded password (CRITICAL): Hardcoded password finding

SQL injection (CRITICAL): SQL injection finding

Operations

Render service logs — agent run complete: Render logs

Quickstart (local)

# 1. Bring up the local dependencies
docker compose up -d

# 2. Set required environment variables
export ANTHROPIC_API_KEY=sk-ant-...
export GITHUB_APP_ID=...           # or use a PAT for Phase 1
export GITHUB_PRIVATE_KEY=...
export GITHUB_WEBHOOK_SECRET=...

# 3. Run the backend
cd backend && ./mvnw spring-boot:run

# 4. Expose your webhook with ngrok (or cloudflared) and register it on your GitHub App
ngrok http 8080

Building the agent in phases

See ARCHITECTURE.md for a full walkthrough of how a PR flows through the system. Short version of the build phases:

  • Phase 0–1: GitHub webhook + service → prove the loop (webhook in, comment out)
  • Phase 2: Schema + pgvector indexing job for repo history
  • Phase 3: Agent loop — wire LangChain4j to Claude with the five tools
  • Phase 4: Kafka + SSE — move the review off the request thread, stream to clients
  • Phase 5: React + TypeScript dashboard — reviews list, live SSE viewer, metrics chart (live on Vercel free tier)
  • Phase 6: JUnit + Mockito + Testcontainers
  • Phase 7: Terraform apply; push images to ECR; kubectl apply
  • Phase 8: Prometheus/Grafana dashboards for tokens, latency, tool success rate
  • Phase 9: Open-source polish — README, demo GIF, license, Show HN

Agent model

Uses claude-opus-4-7 as of this scaffold — Anthropic's current frontier model with a 1M-token context window and native tool-calling. Configure in backend/src/main/resources/application.yml under anthropic.model if you want to swap to Sonnet for cheaper runs.

Key design choices

  • Agent as LangChain4j AI Service — CodeReviewerAgent is a Java interface with @SystemMessage and @UserMessage annotations. LangChain4j generates the implementation and handles the tool-calling loop against Claude's native tool-use API.
  • Kafka between webhook and worker — GitHub expects webhook responses in <10s. Enqueueing to Kafka lets the webhook return immediately while the agent runs asynchronously, and gives horizontal scalability for concurrent PRs.
  • pgvector in the same Postgres as JPA — avoids standing up a separate vector DB. The HNSW index on code_embeddings.embedding with vector_cosine_ops handles semantic search over repo history.
  • Flyway owns the schema, not Hibernate — ddl-auto: validate prevents schema drift. LangChain4j's PgVectorEmbeddingStore is configured with createTable=false so Flyway is the single source of truth.
  • SSE for reasoning stream — simpler than WebSockets for one-way server→client traffic, works through every proxy, native EventSource support in React.

Guardrails

The system prompt (prompts/system_prompt.md) is the single most important file. It defines the severity rubric, the tool-use strategy, and the guardrails that prevent hallucinated findings. Edit it before changing code if review quality is off.

License

MIT (see LICENSE).

Project status

Shipped. End-to-end system is live on a $0/month free tier:

  • Project scaffold and architecture
  • Spring Boot + LangChain4j integration
  • PostgreSQL schema with pgvector
  • Kafka event orchestration
  • GitHub webhook integration — live, posts inline PR comments
  • Free-tier cloud deploy (Render + Neon) — $0/month, live as of 2026-05-11
  • React dashboard — reviews list, live SSE viewer, metrics chart — live on Vercel (see PHASE_5_DASHBOARDS.md)

Built and maintained by @jayapasam9-max.

Ver o original no GitHub

Bom para

Relacionados