bloodbank-event-publisher

Publish and consume typed events on the Bloodbank event bus with RabbitMQ routing.

1|Updated Oct 6, 2025
One-click install
npx skills add https://github.com/delorenj/bloodbank --skill bloodbank-event-publisher
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: bloodbank-event-publisher
Source: https://github.com/delorenj/bloodbank/tree/main/claude_skills/bloodbank_event_publisher
Command: npx skills add https://github.com/delorenj/bloodbank --skill bloodbank-event-publisher

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires aio-pika, pydantic, pydantic-settings, fastapi, uvicorn, typer, httpx, redis.

What problem does it solve?

This Skill addresses the complexity of inter-service communication in agentic AI pipelines and home networks. It eliminates manual event handling, ensures data integrity, and provides comprehensive traceability, preventing lost context and simplifying debugging in distributed systems.

Core Features & Use Cases

  • Type-safe Eventing: Leverage Pydantic models for strict type validation, ensuring reliable data exchange between services and AI agents.
  • Robust Messaging: Built on RabbitMQ for durable, topic-based routing, guaranteeing events are delivered even through system restarts.
  • Automatic Correlation Tracking: Redis-backed correlation IDs automatically link related events, providing a complete audit trail of causation chains for every AI action.
  • Deterministic Event IDs: Generate idempotent UUIDs for events, enabling consumers to easily deduplicate messages and prevent reprocessing.
  • Standardized Error Events: Implement consistent error reporting with .failed and .error event patterns, facilitating automated retry logic and alerting.
  • Use Case: Imagine an AI agent that processes meeting transcripts. This Skill allows the agent to publish a fireflies.transcript.upload event, automatically track its journey through transcription and RAG ingestion, and handle any fireflies.transcript.failed events, ensuring data integrity and a complete audit trail without manual intervention.

Quick Start

1. Start the HTTP server (if not already running)

uvicorn event_producers.http:app --reload --port 8682

2. Publish an LLM prompt event via HTTP

curl -X POST http://localhost:8682/events/llm/prompt
-H "Content-Type: application/json"
-d '{ "provider":"anthropic", "model":"claude-sonnet-4", "prompt":"Summarize this document." }'

Frequently Asked Questions about bloodbank-event-publisher

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I publish typed events across microservices with correlation tracking?

Publish typed events using Pydantic-based EventEnvelope schemas on RabbitMQ's topic routing. Correlation IDs automatically link related events through Redis, creating a complete audit trail of causation chains across your distributed services without manual intervention.

Can I use RabbitMQ with Redis for reliable event-driven AI workflows?

Yes. This Skill combines RabbitMQ for durable, topic-based messaging with Redis-backed correlation tracking. The setup guarantees events persist through restarts and enables deterministic deduplication via idempotent event IDs, ideal for agentic AI pipelines.

What's the fastest way to start publishing events via HTTP and Python?

Start the HTTP server with uvicorn, then POST events to typed endpoints like `/events/llm/prompt`. Alternatively, use the Python SDK or MCP server for programmatic access—all patterns support the same Pydantic schema validation and correlation tracking.

How do I debug event flows and message routing across services?

Enable comprehensive traceability through correlation IDs that link every related event. Rich agent_context and context capture automatically record event provenance, making it easy to trace a message's journey through transcription, RAG ingestion, and error handling.

Do I need to manually handle errors and retries in distributed AI systems?

No. Standardized error events follow `.failed` and `.error` patterns, enabling automated retry logic and alerting. Combined with durable RabbitMQ messaging and correlation tracking, your system handles failure states consistently without custom error plumbing.

What access patterns does this Skill support for publishing events?

Multiple access patterns: HTTP REST endpoints, Python SDK, CLI via Typer, and MCP server. All routes feed the same type-safe event bus backed by RabbitMQ and Redis, letting you integrate with webhooks, APIs, and cross-service tooling seamlessly.