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 GitHubAgent 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-Assistant1 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
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
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

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:

Inline PR comments
Hardcoded password (CRITICAL):

SQL injection (CRITICAL):

Operations
Render service logs — agent run complete:

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 —
CodeReviewerAgentis a Java interface with@SystemMessageand@UserMessageannotations. 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.embeddingwithvector_cosine_opshandles semantic search over repo history. - Flyway owns the schema, not Hibernate —
ddl-auto: validateprevents schema drift. LangChain4j'sPgVectorEmbeddingStoreis configured withcreateTable=falseso 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
EventSourcesupport 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.