convez.ai
MCP Server
qasirdev

daily-briefing

qasirdev/daily-briefing

Ver no GitHub
InicialPluginScore · de 0 a 100

Production multi-agent daily briefing — LangGraph 6-agent pipeline, MCP (PostgreSQL + Google Calendar), CoALA memory, OWASP GenAI security, JIT consent, 90% prompt caching. FastAPI · Next.js 16 · React 19 · Supabase · OpenTelemetry · Prometheus · Docker.

Instalação

$npx convez-ai qasirdev/daily-briefing

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
57%
Último commit
há 4 meses
Versão
—
Issues abertas
1
Contribuidores
1

README

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

🧠 AI Daily Briefing Assistant

Stop losing your mornings to information overload.

One intelligent multi-agent pipeline — your tasks, calendar, and priorities unified into a single, secure, actionable daily briefing.


Production-Ready Multi-Agent AI Platform — Built with enterprise-grade security, OWASP GenAI compliance, and intelligent prompt caching that reduces token costs by 70-90%.

Technology Stack

Python TypeScript FastAPI Next.js React

AI & Orchestration

LangGraph Claude OpenAI Llama MCP

Security & Quality

OWASP GenAI Tests Coverage MyPy Ruff

Infrastructure

Docker PostgreSQL Supabase OpenTelemetry Prometheus Grafana

Key Metrics

Cost Savings Latency Security

CI License


🎯 Why This Project Exists

Knowledge workers lose 30–60 minutes every morning reconciling scattered information across task managers, calendars, and email. Before writing a single line of meaningful work, they're already mentally exhausted from context-switching.

The AI Daily Briefing Assistant eliminates that cognitive overhead entirely.

Every morning at 6:00 AM, a secure, enterprise-grade AI pipeline automatically:

  1. 📋 Pulls Your Tasks — Retrieves highest-priority items from PostgreSQL via secure MCP integration with Row-Level Security
  2. 📅 Fetches Your Calendar — Connects to Google Calendar with time-bounded JIT consent (<15 min token TTL)
  3. 🔍 Generates Your Plan — Uses Claude Opus 4.8 or GPT-5.5 to create an intelligent, time-blocked work plan
  4. ✅ Verifies Quality — Verification Agent validates logic, completeness, and schema compliance
  5. ⚔️ Stress Tests — Adversarial Agent challenges assumptions and finds edge cases
  6. 🛡️ Security Review — Critic Agent scans for prompt injection, jailbreak attempts, and PII leakage
  7. 🎯 Delivers Briefing — Orchestrator synthesizes consensus into one clean, sanitized, actionable briefing

No tab-switching. No manual assembly. No security compromises. Just clarity, from the moment your day begins.

🎁 The Hidden Benefit: 90% Cost Reduction

By structuring agent prompts for caching, the system achieves 70-90% token cost savings while improving response times 2-10×. At scale, that's $18K/month savings without sacrificing quality or security.



💼 Daily Benefits for Knowledge Workers


⚡ At a Glance


🏗️ System Architecture

flowchart TB
    subgraph Client["🌐 Client Layer"]
        UI[Next.js 16 Dashboard<br/>React 19 + Tailwind v4]
    end

    subgraph Container["🐳 Production Container (Docker)"]
        NGINX[Nginx Reverse Proxy<br/>Port 8088 → 80]
        API[FastAPI Backend<br/>LangGraph Multi-Agent Orchestration]
        UI --> NGINX
        NGINX --> API
    end

    subgraph Agents["🤖 Six-Agent Verification Pipeline"]
        ORCH[🎯 Orchestrator<br/>Supervisor + Presenter]
        TASK[📋 Task Agent<br/>Doer]
        CAL[📅 Calendar Agent<br/>Tool Operator]
        FOCUS[🔍 Focus Agent<br/>Planner]
        VERIFY[✅ Verification Agent<br/>Validator]
        ADV[⚔️ Adversarial Agent<br/>Red Team]
        CRIT[🛡️ Critic Agent<br/>Safety Gatekeeper]
        DLQ[💀 Dead Letter Queue]

        ORCH --> TASK
        ORCH --> CAL
        TASK --> FOCUS
        CAL --> FOCUS
        FOCUS --> VERIFY
        VERIFY --> ADV
        ADV --> CRIT
        CRIT --> ORCH
        CRIT -.->|security violation| DLQ
    end

    subgraph Memory["🧠 CoALA 4-Layer Memory"]
        WORK[Working Memory<br/>Context Window]
        SEM[Semantic Memory<br/>PostgreSQL + Vector DB]
        PROC[Procedural Memory<br/>Skills & Tools]
        EPIS[Episodic Memory<br/>Past Sessions]
    end

    subgraph Security["🔐 Security Layer"]
        SPOT[Spotlighting<br/>Indirect Injection Defense]
        CONST[Constitutional Classifiers<br/>Jailbreak Detection]
        POISON[Tool Poisoning Defense<br/>MCP Validation]
        DEPUTY[Confused Deputy Prevention<br/>Delegation Tokens]
    end

    subgraph Integrations["🔌 External Integrations"]
        MCP_PG[(PostgreSQL MCP<br/>Supabase via stdio<br/>RLS + Supavisor)]
        MCP_CAL[(Google Calendar MCP<br/>OAuth 2.0 + JIT Consent<br/>SSRF Protection)]
        LLM[LLM Router<br/>OpenRouter / Claude Opus 4.8<br/>GPT-5.5 / Local Llama 3.1<br/>**90% Cost Savings via Prompt Caching**]
    end

    subgraph Observability["📊 Observability"]
        OTEL[OpenTelemetry<br/>Distributed Tracing]
        PROM[Prometheus Metrics<br/>SLO Monitoring]
        DRIFT[Drift Detection<br/>Dwell Time SLO < 1hr]
    end

    API --> Agents
    API --> Security
    Agents --> Memory
    TASK --> MCP_PG
    CAL --> MCP_CAL
    FOCUS --> LLM
    VERIFY --> LLM
    ADV --> LLM
    CRIT --> LLM
    API --> Observability

Core Design Principles

PrincipleImplementation
🎯 Orchestrator-as-PresenterOnly sanitised markdown reaches users. Agents return strict AgentResultEnvelope JSON; Orchestrator synthesizes final output
🛡️ Zero-Trust SecuritySpotlighting for indirect injection, tool poisoning defense, confused deputy prevention, constitutional classifiers
🧠 Memory ArchitectureCoALA 4-layer model: Working, Semantic, Procedural, Episodic memory with session isolation
⚡ Prompt Caching70-90% token cost reduction via structured prompt caching (Claude + OpenAI)
✅ Multi-Agent VerificationGenerator → Verification → Adversarial → Critic → Consensus workflow prevents hallucinations
🔐 JIT CredentialsShort-lived delegation tokens (<15 min TTL), zero standing permissions

🎓 Technical Innovations & Achievements

🚀 What Makes This Project Special

InnovationTechnical AchievementBusiness Impact
💰 90% Cost ReductionStructured prompt caching with Claude + OpenAI$18K/month savings at 1K requests/day/agent
🔐 Zero-Trust SecurityFirst production implementation of Microsoft Research's Spotlighting + Tool Poisoning Defense>95% injection defense (industry avg: 50-70%)
✅ Multi-Agent VerificationGenerator → Verification → Adversarial → Critic consensus pipeline+20% accuracy, hallucination-resistant
🧠 Memory ArchitectureProduction CoALA 4-layer implementation with session isolationEnterprise-grade context management
⚡ 2-10× FasterPrompt caching + async MCP stdio transportSub-second cached responses
📦 Comprehensive Codebase15,000+ lines of production Python/TypeScript with >80% test coverageDeployment-ready, not a prototype
🛡️ OWASP CompliantFull OWASP GenAI Top 10 coverage (7/7 categories) + OWASP Agent Security Top 10 (8/10)Enterprise security audit-ready
🔍 Observability-FirstOpenTelemetry + Prometheus + Dwell Time SLO <1hrProduction-grade monitoring
🎯 Agent OS KernelScheduler · Memory Manager · Tool Manager · Identity Manager · Security MonitorReusable agent infrastructure
📋 Supply Chain SecurityAI-BOM + OpenSSF Scorecard + Cosign signingProvenance tracking for all AI components

📊 By the Numbers

  • 52 completed tasks across 6 MVPs
  • 121 security gaps addressed (IBM + Claude frameworks)
  • 455 automated tests (unit · security · integration · E2E)
  • 6 specialized agents with multi-layer verification
  • 15K+ lines of production code (backend + frontend + infrastructure)
  • 11-file prompt structure per agent (v2.0.0 standards)
  • 90% token cost savings via caching
  • <10s P95 latency with caching
  • <1hr Dwell Time SLO for security incidents
  • >80% test coverage with strict MyPy
  • 7.0+/10 OpenSSF Scorecard minimum
  • Zero standing permissions (JIT credentials only)

🤖 Multi-Agent Pipeline — How It Works

Each morning, six specialized agents collaborate through a deterministic verification workflow:

1. 📋 Task Agent — Doer

Connects to PostgreSQL via Model Context Protocol (MCP stdio). Retrieves and priority-sorts your tasks using Row-Level Security. Read-only by design — agents never modify your data without explicit consent.

2. 📅 Calendar Agent — Tool Operator

Fetches today's events from Google Calendar via OAuth with time-bounded JIT consent (<15 min TTL). Spotlighting wraps all external data in security markers to prevent indirect prompt injection. SSRF validation blocks unauthorized domains.

3. 🔍 Focus Agent — Planner

Generates an intelligent, time-blocked work plan using Claude Opus 4.8 or GPT-5.5. Zero tool access — pure reasoning. PII-sensitive data automatically routes to local Llama 3.1 70B for privacy. Structured prompts with 90% token cost savings via caching.

4. ✅ Verification Agent — Validator

Validates Focus Agent output for schema compliance, logic correctness, and completeness. First layer of quality assurance in the multi-agent verification pipeline.

5. ⚔️ Adversarial Agent — Red Team

Challenges assumptions, finds edge cases, and stress-tests the generated plan. Contrarian perspective ensures robustness before final review.

6. 🛡️ Critic Agent — Safety Gatekeeper

Final security and quality review. Runs constitutional classifiers, detects jailbreak attempts, and scans for PII leakage. Security violations are never retried — immediately escalated to Dead Letter Queue.

7. 🎯 Orchestrator — Supervisor + Presenter

Evaluates consensus across all agents. Synthesizes final briefing only after multi-agent verification. Applies dual-layer sanitization (nh3 backend + DOMPurify frontend). The only agent that produces user-facing markdown.


🧠 Memory Architecture (CoALA 4-Layer Model)

LayerPurposeImplementationRetention
Working MemoryCurrent context window, active task stateLangGraph state + context managementSession-scoped
Semantic MemoryFacts, policies, domain knowledgePostgreSQL + Vector DB (optional RAG)Persistent
Procedural MemorySkills, tools, progressive disclosureJSON skill definitions + access controlPersistent
Episodic MemoryDistilled lessons from past sessionsPostgreSQL with session isolationConfigurable (90 days default)

Security: Session isolation prevents memory bleed between users. All memory sources treated as untrusted with spotlighting and integrity validation.


🛠️ Technology Stack — Enterprise-Grade Tools

🤖 AI & Orchestration

TechnologyVersionWhy We Chose ItKey Benefit
LangGraph0.4+Deterministic state machine for multi-agent workflowsPredictable execution, cycle detection, automatic checkpointing
Claude Opus 4.8LatestAnthropic's flagship model with adaptive thinkingSuperior reasoning for agentic workflows, 90% cost savings via caching
GPT-5.5LatestOpenAI's production-optimized modelFast inference, structured outputs, cost-effective
OpenRouterLatestUnified LLM routing across 200+ providersModel fallback, A/B testing, zero vendor lock-in
Model Context Protocol (MCP)stdioStandardized tool interface for agentsSecure, schema-validated tool access with sandboxing
Local LLM (Llama 3.1 70B)3.1Privacy-preserving on-prem inferencePII/confidential data never leaves infrastructure
Prompt CachingClaude + OpenAI70-90% token cost reduction$18K/month savings at scale, 2-10x faster responses

Backend

TechnologyWhy We Chose ItBenefit
FastAPIModern async Python API frameworkAutomatic OpenAPI docs, native async support, 3× faster than Flask for I/O-bound workloads
Python 3.12Latest stable Python runtimeImproved performance, better error messages, asyncio improvements
Pydantic v2Data validation and settings management5–50× faster than v1; strict type enforcement prevents malformed agent payloads
LangChain ecosystemLLM tooling and integrationsBattle-tested prompt management, retry logic, and observability hooks
uvUltra-fast Python package managerDeterministic installs, lockfile enforcement, 10–100× faster than pip
Alembic + SQLAlchemy asyncDatabase migrations and ORMType-safe async queries; reproducible schema evolution

Frontend

TechnologyWhy We Chose ItBenefit
Next.js 16 (App Router)React meta-framework with server componentsStreaming UI, built-in routing, SEO-ready, server-side rendering reduces time-to-first-byte
React 19Latest React with concurrent featuresServer Components reduce JS bundle size; useOptimistic for snappy UX
TypeScript 5.xTyped JavaScriptCatches integration errors at compile time; agent envelope types shared end-to-end
Tailwind CSS v4Utility-first CSS frameworkConsistent design system, zero unused CSS in production
DOMPurifyClient-side HTML sanitisationLast line of defence — strips any unsafe markup before rendering briefing content
ZodTypeScript schema validationFrontend validates API responses independently; no implicit trust of backend payloads

Data & Storage

TechnologyWhy We Chose ItBenefit
Supabase (PostgreSQL)Managed Postgres with Row-Level SecurityPer-user data isolation enforced at the database layer, not just application logic
Supavisor (port 6543)Connection pooler for SupabaseHandles thousands of concurrent connections without PostgreSQL saturation
PostgreSQL MCP (stdio)Agent-safe database accessParameterised queries only; agents cannot execute arbitrary SQL
Google Calendar MCP (stdio)Calendar integrationScoped calendar.readonly access; OAuth refresh handled securely via env

Security

TechnologyWhy We Chose ItBenefit
nh3Rust-backed HTML sanitiserAllowlist-based; strips scripts, iframes, and unsafe attributes before storage
PromptInjectionDetectorCustom regex + Unicode normalisationCatches obfuscated injection attempts that bypass simple keyword filters
PIIDetector + mask_pii()Custom PII scanner and maskerPrevents email, phone, SSN, and card numbers from leaking into LLM payloads
SSRFValidatorURL allowlist + private IP blockerMCP integrations cannot be redirected to internal network endpoints
SlowAPIFastAPI rate limitingEnforces per-endpoint request quotas; returns proper 429 responses
pyjwt[crypto]JWT with RS256 signingProduction-grade asymmetric token verification

Observability & Infrastructure

TechnologyWhy We Chose ItBenefit
OpenTelemetryVendor-neutral distributed tracingtrace_id propagated from HTTP request through every agent and log line
PrometheusMetrics collection and alertingSLO tracking, security violation counters, per-agent token usage (http://localhost:9090)
GrafanaVisualization and dashboardsReal-time monitoring, cache performance, dwell time SLO, MITRE coverage (http://localhost:3000)
AlertmanagerAlert routing and deduplicationPagerDuty integration, incident management (http://localhost:9093)
LokiLog aggregation (optional)Centralized logging with retention policies, indexed queries
structlogStructured JSON loggingMachine-parseable logs with consistent fields; security channel for audit events
Docker (multi-stage)Containerised deploymentReproducible builds; dev/prod parity; minimal attack surface via multi-stage
NginxReverse proxyTLS termination, static asset serving, upstream health-check routing
SupervisordProcess manager inside containerManages uvicorn + Nginx as co-located processes in a single container
Cosign + SigstoreContainer image signingKeyless supply chain verification via GitHub OIDC — proves image provenance
GitHub ActionsCI/CD pipelineAutomated lint, typecheck, test, build, and signed image publish on every push

Development Experience

TechnologyWhy We Chose ItBenefit
RuffExtremely fast Python linterReplaces Flake8 + isort + pyupgrade; 100× faster; enforces consistent code style
MyPy (strict)Static type checking for PythonCatches type errors at development time, not in production
pytestPython test framework455 tests including unit, security, integration, and E2E scenarios
Cursor Development AgentsAI-assisted implementationSpecialised coding, testing, refactor, and documentation agents with scoped rules

🔐 Security Posture — Zero-Trust from Day One

This project implements OWASP GenAI Top 10 — the industry standard for LLM application security — with comprehensive defense-in-depth controls.

🛡️ Additional Security Layers

  • 🔍 Drift Detection: Real-time behavioral monitoring with Dwell Time SLO <1 hour
  • 📊 MITRE ATT&CK Mapping: >80% coverage of applicable AI system techniques
  • 🔐 Cryptographic Audit Logs: Append-only, tamper-evident with cryptographic sealing
  • 🆔 NHI Registry: X.509 certificate-based agent identity (not UUIDs)
  • 🧪 OWASP Agent Security Top 10: Comprehensive coverage planned (8/10 categories)

Full threat model, attack scenarios, and mitigation strategies: docs/SECURITY.md


🚀 Quick Start

Prerequisites

  • uv >= 0.5
  • Node.js 22.x (nvm use)
  • Docker 27+ (optional — for full stack)

Backend — local dev on port 8010

cp .env.example .env
uv sync --all-extras
uv run alembic upgrade head        # run once against Supabase
uv run uvicorn backend.main:app --reload \
  --reload-dir backend --reload-dir prompts \
  --host 127.0.0.1 --port 8010
curl http://127.0.0.1:8010/health        # liveness
curl http://127.0.0.1:8010/health/ready  # readiness

Docker — full stack on port 8088

docker compose up --build -d
curl http://localhost:8088/health

See docs/guidence/docker-setup.md and docs/guidence/try-it-locally.md.

Frontend — local dev on port 3010

cd frontend && npm ci && npm run dev

Open http://localhost:3010 — API auto-detects backend at port 8010 (or 8088 in Docker mode).

Verify quality locally

uv run ruff check backend     # lint
uv run mypy backend           # type check
uv run pytest                 # 455 tests

🏭 Production Deployment

# 1. Configure secrets
cp .env.production.example .env
# Set JWT_SECRET_KEY, ADMIN_API_KEY, LLM keys

# 2. Verify signed image from GHCR
cosign verify \
  --certificate-identity-regexp='.*' \
  --certificate-oidc-issuer='https://token.actions.githubusercontent.com' \
  ghcr.io/qasirdev/daily-briefing@sha256:<digest>

# 3. Deploy
docker compose up -d

See infrastructure/DEPLOYMENT.md for full rollout and rollback runbook.


📐 Project Structure

📁 daily-briefing/
├── 📁 backend/                    FastAPI app · 6-agent pipeline · MCP clients
│   ├── agents/                    Task · Calendar · Focus · Verification · Adversarial · Critic · Orchestrator
│   ├── mcp/                       MCP stdio clients (PostgreSQL, Google Calendar)
│   ├── security/                  Spotlighting · Constitutional classifiers · Tool poisoning defense
│   ├── memory/                    CoALA 4-layer: Working · Semantic · Procedural · Episodic
│   ├── kernel/                    Agent OS: Scheduler · Memory Manager · Tool Manager · Identity Manager
│   ├── graph/                     LangGraph state machine · Consensus workflow · DLQ routing
│   ├── llm/                       Prompt caching · Model routing · PII-aware fallback
│   ├── observability/             OpenTelemetry · Prometheus · Drift detection · Dwell Time SLO
│   └── tests/                     455 tests: unit · security · integration · E2E
│
├── 📁 frontend/                   Next.js 16 dashboard
│   ├── app/                       App Router · Server Components · API routes
│   ├── components/                BriefingDashboard · ConsentModal · ObservabilityBadge · ReasoningTrace
│   └── lib/                       API client · Schema validation · Cost tracking
│
├── 📁 prompts/                    v2.0.0 structured prompts (11 files per agent)
│   ├── orchestrator/              system.md · context.md · instructions.md · examples.md · output-schema.md
│   ├── task/                      reasoning.md · tools.md · guardrails.md · quality-checklist.md · CHANGELOG.md
│   ├── calendar/                  (Same 11-file structure)
│   ├── focus/                     ✅ Upgraded to v2.0.0 with prompt caching
│   ├── verification/              ✅ NEW: Multi-agent verification
│   ├── adversarial/               ✅ NEW: Red team agent
│   └── critic/                    Enhanced with constitutional classifiers
│
├── 📁 docs/                       Comprehensive documentation
│   ├── ARCHITECTURE.md            6-agent system · Memory architecture · Agent OS Kernel
│   ├── SECURITY.md                OWASP GenAI Top 10 · Zero-trust controls · Threat model
│   ├── PROMPT-ENGINEERING-GUIDE.md v2.0.0 standards · Claude + OpenAI best practices
│   ├── MEMORY-ARCHITECTURE.md     CoALA 4-layer specification
│   ├── AGENT-OS-KERNEL.md         Scheduler · Tool Manager · Identity Manager
│   ├── OBSERVABILITY.md           Metrics · Tracing · Dwell Time SLO · MITRE ATT&CK
│   ├── SUPPLY-CHAIN-SECURITY.md   AI-BOM · OpenSSF Scorecard · Vendor assessments
│   ├── MCP.md                     Tool schemas · Validation · Spotlighting
│   ├── AGENTIC-CONSENT.md         JIT credentials · Time-bounded tokens
│   ├── LOCAL-LLM.md               Llama 3.1 70B benchmarks · Privacy routing
│   ├── DATA-OWNERSHIP.md          GDPR compliance · Data portability
│   └── guidence/                  docker-setup.md · supabase-setup.md · google-calendar-setup.md
│
├── 📁 infrastructure/             Production deployment
│   ├── docker-compose.yml         Single container deployment
│   ├── Dockerfile                 Multi-stage build with security hardening
│   ├── nginx.conf                 Reverse proxy (port 8088)
│   ├── supervisord.conf           Process orchestration
│   ├── ai-bom.yaml                AI Bill of Materials
│   └── DEPLOYMENT.md              Rollout · Rollback · Emergency procedures
│
├── 📁 .github/workflows/          CI/CD automation
│   ├── ci.yml                     Lint · Type check · Test · Security scan
│   └── docker-publish.yml         Build · Sign (Cosign) · Push to GHCR
│
├── 📁 .cursor/rules/              Cursor Agent development standards
│   ├── coding.mdc                 Python/TypeScript · Agent patterns
│   ├── testing.mdc                455 tests · OWASP boundary testing
│   ├── refactor.mdc               Schema validation · Sanitization
│   └── docs.mdc                   Documentation standards
│
└── AGENT.md                       Root index · Workflow rules · MVP tracking

📊 Engineering Standards

PracticeImplementation
Testing455 pytest cases — unit, security, live stdio integration, E2E
Static analysisRuff lint + MyPy strict mode on all backend code
CI/CDGitHub Actions: lint → typecheck → test → Docker build → sign → publish
Image supply chainGHCR publish + Cosign keyless signing + cosign verify gate before deploy
Config managementPydantic Settings + .env.example + .env.production.example
DocumentationArchitecture · Security · Observability · Deployment runbooks
SLO targets99.5% availability · P95 latency < 10s (see docs/OBSERVABILITY.md)

📚 Documentation Map

DocumentPurpose
docs/ARCHITECTURE.mdSystem design, agent roles, data flows
docs/SECURITY.mdOWASP GenAI matrix, threat model, controls
docs/OBSERVABILITY.mdTracing, Prometheus metrics, SLOs
docs/guidence/observability/README.mdLocal Prometheus, Grafana, PagerDuty setup
docs/AGENTIC-CONSENT.mdConsent flows, token lifecycle, revocation
docs/LOCAL-LLM.mdLocal model benchmarks, hardware requirements
docs/DATA-OWNERSHIP.mdGDPR compliance, retention, PII handling
infrastructure/DEPLOYMENT.mdProduction rollout and rollback
docs/PLAN.mdImplementation roadmap — 52/52 tasks complete
AGENT.mdEngineering workflow and conventions

🔍 ATS-Optimized Technology Keywords

Comprehensive Production Codebase with enterprise-grade multi-agent AI system

Core Technologies

Python 3.12+, FastAPI 0.115+, Pydantic v2, async/await, asyncio, type hints, uv package manager,
LangGraph 0.4+, LangChain ecosystem, multi-agent orchestration, agentic AI workflows,
Claude Opus 4.8, GPT-5.5, GPT-4o-mini, OpenRouter, Anthropic SDK, OpenAI SDK,
Llama 3.1 70B, local LLM inference, model routing, prompt caching, prompt engineering,
CoALA memory architecture, working memory, semantic memory, episodic memory, procedural memory,
context window management, RAG (Retrieval Augmented Generation), vector databases

Backend & Infrastructure

httpx async client, structlog structured logging, uvicorn ASGI server, tenacity retry logic,
PostgreSQL 16+, Supabase, Supavisor connection pooling, Row-Level Security (RLS),
Alembic migrations, SQLAlchemy async ORM, database schema design,
Model Context Protocol (MCP), MCP stdio transport, MCP sandboxing, tool validation,
Redis cache, session management, credential broker, Vault integration,
Docker multi-stage builds, Docker Compose, Nginx reverse proxy, Supervisord process manager,
GitHub Actions CI/CD, Cosign image signing, Sigstore, supply chain security,
Prometheus metrics, OpenTelemetry tracing, OTLP, distributed tracing, trace propagation,
Grafana dashboards, SLO monitoring, Dwell Time SLO, drift detection

Frontend & UI

TypeScript 5.x+, React 19, Next.js 16 App Router, Server Components, Server Actions,
Tailwind CSS v4, responsive design, utility-first CSS, component libraries,
DOMPurify XSS protection, Zod schema validation, client-side validation,
React Hooks, useOptimistic, Suspense, streaming SSR, SEO optimization,
accessibility (WCAG 2.1), semantic HTML, ARIA labels

Security & Compliance

OWASP GenAI Top 10, LLM security, prompt injection defense, indirect injection prevention,
spotlighting, constitutional classifiers, jailbreak detection, tool poisoning defense,
confused deputy prevention, delegation tokens, JIT credentials, zero standing permissions,
PII masking, PII detection, data classification, GDPR compliance, data portability,
OAuth 2.0, consent management, agentic consent, time-bounded authorization,
SSRF validation, allowlist enforcement, rate limiting (slowapi), circuit breakers,
sanitization (nh3), HTML sanitization, markdown sanitization, output validation,
JWT RS256, cryptographic signing, X.509 certificates, NHI (Non-Human Identity),
TLS 1.3, secrets management, audit logging, cryptographic sealing, append-only logs,
dead letter queue (DLQ), error handling, graceful degradation

Testing & Quality Assurance

pytest, unit testing, integration testing, E2E testing, security testing,
OWASP testing, injection testing, sanitization testing, boundary testing,
test coverage, MyPy strict type checking, Ruff linting, code quality,
GitHub Actions CI, automated testing, continuous integration,
AI-BOM (AI Bill of Materials), OpenSSF Scorecard, dependency scanning,
supply chain security, vulnerability management, SAST (Static Application Security Testing)

Architecture & Patterns

multi-agent systems, agent orchestration, supervisor pattern, presenter pattern,
verification pipeline, adversarial testing, consensus mechanisms, state machines,
microservices architecture, single container deployment, hybrid deployment,
event-driven architecture, async patterns, retry logic, timeout handling,
memory architecture, context management, session isolation, data provenance,
zero-trust architecture, defense in depth, security by design, privacy by design,
Twelve-Factor App methodology, production readiness, enterprise architecture

AI/ML & LLM Operations

Large Language Models (LLM), agentic AI, AI agents, AI safety, AI governance,
prompt engineering, few-shot learning, chain-of-thought reasoning, structured outputs,
token optimization, prompt caching, cost optimization, model fallback,
data classification, PII routing, confidential data handling, model selection,
LLM observability, token usage tracking, latency monitoring, quality metrics,
hallucination prevention, output validation, reasoning traces, explainability

APIs & Integrations

RESTful APIs, Google Calendar API, OAuth 2.0 flows, API security,
MCP protocol, stdio transport, HTTP transport, tool calling, function calling,
JSON schemas, API documentation, OpenAPI/Swagger, Pydantic models,
webhook handling, event processing, background jobs, task queues

📦 Implementation Status

Gap Coverage Summary

Development Phase (Weeks 1-8):

  • P0 Critical Gaps (24): ✅ All addressed
  • P1 High Gaps (52): ✅ All addressed
  • P2 Medium Gaps (45): ✅ All addressed
  • Total Coverage: 121/121 gaps from IBM Multi-Agent AI + Claude Zero-Trust frameworks

Production Phase (Ongoing - Weeks 9-17):

  • P0 Production Gaps (14): 🔄 In progress (CORS, TLS, staging, disaster recovery)
  • P1 Production Gaps (24): 🔄 Planned (Grafana dashboards, alerting, load testing)
  • P2 Production Gaps (15): 📋 Backlog (Enterprise features, post-launch)
  • Total Production Gaps: 53 gaps tracked in docs/gaps/production/PROD-GAP-ANALYSIS-REVIEW.md

Production Status: Code is feature-complete with 455 automated tests. Production infrastructure (staging, DR, monitoring alerts, TLS, load testing) is being hardened in PROD Weeks 1-9. See PROD-INFRA-OPTIONS.md for deployment options.


📚 Documentation

Core Documentation

DocumentPurpose
007-01-ai-daily-briefing-assistant-v2.0.0.mdComplete v2.0.0 specification with 121 gap coverage
AGENT.mdRoot index · Workflow rules · Engineering standards
docs/ARCHITECTURE.mdSystem design · 6-agent pipeline · Data flows · Memory architecture
docs/SECURITY.mdOWASP GenAI Top 10 · Zero-trust controls · Threat model
docs/PROMPT-ENGINEERING-GUIDE.mdv2.0.0 standards · Claude + OpenAI best practices · Prompt caching
docs/OBSERVABILITY.mdMetrics · Tracing · Dwell Time SLO · MITRE ATT&CK
docs/MCP.mdTool schemas · Validation · Spotlighting · Sandboxing

Production Documentation

DocumentPurpose
docs/gaps/production/PROD-GAP-ANALYSIS-REVIEW.md53 production gaps · P0/P1/P2 priorities · Implementation roadmap
docs/gaps/production/PROD-INFRA-OPTIONS.md3 deployment options ($5-200/month) · VPS/PaaS/Cloud comparison
docs/gaps/production/PROD-PROPOSAL-REVIEW-SUMMARY.mdProduction readiness assessment · Risk analysis · Go/no-go criteria
docs/gaps/production/PROD-KICKOFF-PROMPT.mdProduction implementation guide · Week-by-week plan
docs/DEPLOYMENT-GATES.mdMetric-based release criteria · Gate requirements

Setup Guides

DocumentPurpose
docs/guidence/docker-setup.mdProduction deployment · Docker Compose · Nginx config
docs/guidence/try-it-locally.mdLocal development setup · Backend + Frontend
docs/guidence/observability/README.mdPrometheus + Grafana + Alertmanager setup · Dashboards
docs/guidence/supabase-setup.mdPostgreSQL setup · Row-Level Security · Migrations
docs/guidence/google-calendar-setup.mdOAuth 2.0 setup · MCP calendar integration

🚀 Quick Start

Prerequisites

# Required
uv >= 0.5          # Python package manager
node >= 22.x       # Node.js (use nvm)
docker >= 27.x     # Container runtime (optional for full stack)

# Recommended
supabase CLI       # For database management
cosign             # For image verification

Production Deployment Options

Three cost-effective infrastructure options are available:

OptionProviderCost/MonthBest ForSetup Guide
🥇 VPSHetzner Cloud, DigitalOcean$5-20MVP, 10-5,000 usersSingle server + Docker Compose
🥈 Managed PaaSRender, Railway, Fly.io$40-80Teams, auto-scalingZero-ops, push-to-deploy
🥉 Managed CloudAWS ECS, Azure Container Apps$100-200Enterprise, complianceFull managed services

Complete infrastructure comparison, cost breakdowns, and deployment guides: docs/gaps/production/PROD-INFRA-OPTIONS.md

Observability Stack (all options):

  • Prometheus (metrics) + Grafana (dashboards) + Loki (logs)
  • Setup: docs/guidence/observability/docker-compose.observability.yml
  • Grafana access: http://localhost:3000 or http://<your-server>:3000

Local Development

# 1. Clone and setup
git clone <repository-url>
cd daily-briefing
cp .env.example .env  # Configure your environment

# 2. Backend (port 8010)
uv sync --all-extras
uv run alembic upgrade head
uv run uvicorn backend.main:app --reload \
  --reload-dir backend --reload-dir prompts \
  --host 127.0.0.1 --port 8010

# 3. Frontend (port 3010)
cd frontend && npm ci && npm run dev

# 4. Verify
curl http://localhost:8010/health        # Backend liveness
curl http://localhost:8010/health/ready  # Backend readiness
open http://localhost:3010               # Frontend dashboard

Docker Production Stack

# 1. Main application (single container on port 8088)
docker compose up --build -d
curl http://localhost:8088/health
open http://localhost:8088

# 2. Observability stack (Prometheus + Grafana + Alertmanager)
cd docs/guidence/observability
cp observability.env.example .env
# Edit .env — set GRAFANA_ADMIN_PASSWORD and PAGERDUTY_ROUTING_KEY (optional)
docker compose -f docker-compose.observability.yml up -d

# Access monitoring dashboards
# 📊 Grafana: http://localhost:3000 (admin/<your-password>)
# 📈 Prometheus: http://localhost:9090
# 🚨 Alertmanager: http://localhost:9093

Observability Dashboards

Grafana (http://localhost:3000) provides real-time monitoring:

DashboardMetricsPurpose
SLO DashboardAvailability, Latency P95/P99, Error RateOverall system health
Prompt Cache PerformanceCache hit rate (>70%), tokens saved, cost savingsToken optimization tracking
Dwell Time SLOSecurity incident detection time (target <1hr)Security posture monitoring
MITRE ATT&CK CoverageTechnique coverage ratio (target ≥80%)Security defense coverage
Agent PerformancePer-agent latency, token usage, consensus metricsAgent pipeline health

Prometheus (http://localhost:9090) exposes raw metrics:

  • briefing_generation_duration_seconds — End-to-end latency
  • security_dwell_time_seconds — Time to detect incidents
  • llm_cache_hits_total / llm_cache_misses_total — Cache efficiency
  • security_mitre_coverage_ratio — Defense coverage
  • consensus_disagreement_total — Multi-agent verification quality

See docs/guidence/observability/README.md and docs/guidence/try-it-locally.md for detailed setup instructions.


🧪 Testing & Quality

# Run all quality checks
uv run ruff check backend         # Lint
uv run ruff format backend        # Format
uv run mypy backend               # Type check (strict mode)
uv run pytest                     # 455 tests (unit · security · integration · E2E)
uv run pytest --cov=backend       # Coverage report (>80%)

# Security-specific tests
uv run pytest backend/tests/security/  # OWASP GenAI boundary tests

📄 License

Private — Internal use only. All rights reserved.


Production-Ready Multi-Agent AI Platform

Version 2.0.0 | June 2026

Built with ❤️ using Claude Opus 4.8, GPT-5.5, and Llama 3.1 70B

Specification v2.0.0 incorporates 121 security gaps, official Claude + OpenAI prompt engineering guidance, and enterprise-grade multi-agent verification patterns.


See 007-01-ai-daily-briefing-assistant-v2.0.0.md for complete technical specification

Ver o original no GitHub

Bom para

Relacionados