Skip to content

GetBindu/Bindu

BranchesTags

Repository files navigation

Bindu

The identity, communication & payments layer for AI agents

License Hits Python Version PyPI version PyPI Downloads Coverage Tests Discord Documentation PRs Welcome GitHub stars

Bindu (read: binduu) is an operating layer for AI agents that provides identity, communication, and payment capabilities. It delivers a production-ready service with a convenient API to connect, authenticate, and orchestrate agents across distributed systems using open protocols: A2A, AP2, and X402.

Built with a distributed architecture (Task Manager, scheduler, storage), Bindu makes it fast to develop and easy to integrate with any AI framework. Transform any agent framework into a fully interoperable service for communication, collaboration, and commerce in the Internet of Agents.

🌟 Register your agent • 🌻 Documentation • 💬 Discord Community


🎥 Watch Bindu in Action

📋 Prerequisites

Before installing Bindu, ensure you have:

Verify Your Setup

# Check Python version
python --version  # Should show 3.12 or higher

# Check UV installation
uv --version

📦 Installation

Windows users note (Git & GitHub Desktop)

On some Windows systems, git may not be recognized in Command Prompt even after installation due to PATH configuration issues.

If you face this issue, you can use GitHub Desktop as an alternative:

  1. Install GitHub Desktop from https://desktop.github.com/
  2. Sign in with your GitHub account
  3. Clone the repository using the repository URL: https://github.com/getbindu/Bindu.git

GitHub Desktop allows you to clone, manage branches, commit changes, and open pull requests without using the command line.

# Install Bindu
uv add bindu

# For development (if contributing to Bindu)
# Create and activate virtual environment
uv venv --python 3.12.9
source .venv/bin/activate  # On macOS/Linux
# .venv\Scripts\activate  # On Windows

uv sync --dev
Common Installation Issues (click to expand)
Issue Solution
uv: command not found Restart your terminal after installing UV. On Windows, use PowerShell
Python version not supported Install Python 3.12+ from python.org
Virtual environment not activating (Windows) Use PowerShell and run .venv\Scripts\activate
Microsoft Visual C++ required Download Visual C++ Build Tools
ModuleNotFoundError Activate venv and run uv sync --dev

🚀 Quick Start

Option 1: Using Cookiecutter (Recommended)

Time to first agent: ~2 minutes ⏱️

# Install cookiecutter
uv add cookiecutter

# Create your Bindu agent
uvx cookiecutter https://github.com/getbindu/create-bindu-agent.git

That's it! Your local agent becomes a live, secure, discoverable service. Learn more →

💡 Pro Tip: Agents created with cookiecutter include GitHub Actions that automatically register your agent in the Bindu Directory when you push to your repository. No manual registration needed!

Option 2: Manual Setup

View code example (click to expand)

Create your agent script my_agent.py:

from bindu.penguin.bindufy import bindufy
from agno.agent import Agent
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.models.openai import OpenAIChat

# Define your agent
agent = Agent(
    instructions="You are a research assistant that finds and summarizes information.",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
)

# Configuration
config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"]
}

# Handler function
def handler(messages: list[dict[str, str]]):
    """Process messages and return agent response.

    Args:
        messages: List of message dictionaries containing conversation history

    Returns:
        Agent response result
    """
    result = agent.run(input=messages)
    return result

# Bindu-fy it
bindufy(config, handler)

Your agent is now live at http://localhost:3773 and ready to communicate with other agents.

Option 3: Minimal Echo Agent (Testing)

View minimal example (click to expand)

Smallest possible working agent:

from bindu.penguin.bindufy import bindufy

def handler(messages):
    return [{"role": "assistant", "content": messages[-1]["content"]}]

config = {
    "author": "your.email@example.com",
    "name": "echo_agent",
    "description": "A basic echo agent for quick testing.",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": []
}

bindufy(config, handler)

Run and test:

# Start the agent
python examples/echo_agent.py
Test the agent with curl (click to expand)

Input:

curl --location 'http://localhost:3773/' \
--header 'Content-Type: application/json' \
--data '{
    "jsonrpc": "2.0",
    "method": "message/send",
    "params": {
        "message": {
            "role": "user",
            "parts": [
                {
                    "kind": "text",
                    "text": "Quote"
                }
            ],
            "kind": "message",
            "messageId": "550e8400-e29b-41d4-a716-446655440038",
            "contextId": "550e8400-e29b-41d4-a716-446655440038",
            "taskId": "550e8400-e29b-41d4-a716-446655440300"
        },
        "configuration": {
            "acceptedOutputModes": [
                "application/json"
            ]
        }
    },
    "id": "550e8400-e29b-41d4-a716-446655440024"
}'

Output:

{
    "jsonrpc": "2.0",
    "id": "550e8400-e29b-41d4-a716-446655440024",
    "result": {
        "id": "550e8400-e29b-41d4-a716-446655440301",
        "context_id": "550e8400-e29b-41d4-a716-446655440038",
        "kind": "task",
        "status": {
            "state": "submitted",
            "timestamp": "2025-12-16T17:10:32.116980+00:00"
        },
        "history": [
            {
                "message_id": "550e8400-e29b-41d4-a716-446655440038",
                "context_id": "550e8400-e29b-41d4-a716-446655440038",
                "task_id": "550e8400-e29b-41d4-a716-446655440301",
                "kind": "message",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote"
                    }
                ],
                "role": "user"
            }
        ]
    }
}

Check the status of the task

curl --location 'http://localhost:3773/' \
--header 'Content-Type: application/json' \
--data '{
    "jsonrpc": "2.0",
    "method": "tasks/get",
    "params": {
        "taskId": "550e8400-e29b-41d4-a716-446655440301"
    },
    "id": "550e8400-e29b-41d4-a716-446655440025"
}'

Output:

{
    "jsonrpc": "2.0",
    "id": "550e8400-e29b-41d4-a716-446655440025",
    "result": {
        "id": "550e8400-e29b-41d4-a716-446655440301",
        "context_id": "550e8400-e29b-41d4-a716-446655440038",
        "kind": "task",
        "status": {
            "state": "completed",
            "timestamp": "2025-12-16T17:10:32.122360+00:00"
        },
        "history": [
            {
                "message_id": "550e8400-e29b-41d4-a716-446655440038",
                "context_id": "550e8400-e29b-41d4-a716-446655440038",
                "task_id": "550e8400-e29b-41d4-a716-446655440301",
                "kind": "message",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote"
                    }
                ],
                "role": "user"
            },
            {
                "role": "assistant",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote"
                    }
                ],
                "kind": "message",
                "message_id": "2f2c1a8e-68fa-4bb7-91c2-eac223e6650b",
                "task_id": "550e8400-e29b-41d4-a716-446655440301",
                "context_id": "550e8400-e29b-41d4-a716-446655440038"
            }
        ],
        "artifacts": [
            {
                "artifact_id": "22ac0080-804e-4ff6-b01c-77e6b5aea7e8",
                "name": "result",
                "parts": [
                    {
                        "kind": "text",
                        "text": "Quote",
                        "metadata": {
                            "did.message.signature": "5opJuKrBDW4woezujm88FzTqRDWAB62qD3wxKz96Bt2izfuzsneo3zY7yqHnV77cq3BDKepdcro2puiGTVAB52qf"
                        }
                    }
                ]
            }
        ]
    }
}

Postgres Storage

Bindu uses PostgreSQL as its persistent storage backend for production deployments. The storage layer is built with SQLAlchemy's async engine and uses imperative mapping with protocol TypedDicts.

Its Optional - InMemoryStorage is used by default.

📊 Storage Structure

The storage layer uses three main tables:

  1. tasks_table: Stores all tasks with JSONB history and artifacts
  2. contexts_table: Maintains context metadata and message history
  3. task_feedback_table: Optional feedback storage for tasks

⚙️ Configuration

View configuration example (click to expand)

Configure PostgreSQL connection in your environment or settings: provide the connection string in the config of the agent.

config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"],
    "storage": {
        "type": "postgres",
        "database_url": "postgresql+asyncpg://bindu:bindu@localhost:5432/bindu",  # pragma: allowlist secret
        "run_migrations_on_startup": False,
    },
}

💡 Task-First Pattern: The storage supports Bindu's task-first approach where tasks can be continued by appending messages to non-terminal tasks, enabling incremental refinements and multi-turn conversations.


Redis Scheduler

Bindu uses Redis as its distributed task scheduler for coordinating work across multiple workers and processes. The scheduler uses Redis lists with blocking operations for efficient task distribution.

Its Optional - InMemoryScheduler is used by default.

⚙️ Configuration

View configuration example (click to expand)

Configure Redis connection in your agent config:

config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"],
     "scheduler": {
        "type": "redis",
        "redis_url": "redis://localhost:6379/0",
    },
}

All operations are queued in Redis and processed by available workers using a blocking pop mechanism, ensuring efficient distribution without polling overhead.


Retry Mechanism

Automatic retry logic with exponential backoff for resilient Bindu agents

Bindu includes a built-in Tenacity-based retry mechanism to handle transient failures gracefully across workers, storage, schedulers, and API calls. This ensures your agents remain resilient in production environments.

⚙️ Default Settings

If not configured, Bindu uses these defaults:

Operation Type Max Attempts Min Wait Max Wait
Worker 3 1.0s 10.0s
Storage 5 0.5s 5.0s
Scheduler 3 1.0s 8.0s
API 4 1.0s 15.0s

Sentry Integration

Real-time error tracking and performance monitoring for Bindu agents

Sentry is a real-time error tracking and performance monitoring platform that helps you identify, diagnose, and fix issues in production. Bindu includes built-in Sentry integration to provide comprehensive observability for your AI agents.

⚙️ Configuration

View configuration example (click to expand)

Configure Sentry directly in your bindufy() config:

config = {
    "author": "gaurikasethi88@gmail.com",
    "name": "echo_agent",
    "description": "A basic echo agent for quick testing.",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": [],
    "storage": {
        "type": "postgres",
        "database_url": "postgresql+asyncpg://bindu:bindu@localhost:5432/bindu",  # pragma: allowlist secret
        "run_migrations_on_startup": False,
    },
    # Scheduler configuration (optional)
    # Use "memory" for single-process (default) or "redis" for distributed multi-process
    "scheduler": {
        "type": "redis",
        "redis_url": "redis://localhost:6379/0",
    },
    # Sentry error tracking (optional)
    # Configure Sentry directly in code instead of environment variables
    "sentry": {
        "enabled": True,
        "dsn": "https://252c0197ddeafb621f91abdbb59fa819@o4510504294612992.ingest.de.sentry.io/4510504299069520",
        "environment": "development",
        "traces_sample_rate": 1.0,
        "profiles_sample_rate": 0.1,
    },
}

def handler(messages):
    # Your agent logic
    pass

bindufy(config, handler)

🚀 Getting Started

  1. Create Sentry Account: Sign up at sentry.io
  2. Get Your DSN: Copy from project settings
  3. Configure Bindu: Add sentry config (see above)
  4. Run Your Agent: Sentry initializes automatically

📚 See the full Sentry documentation for complete details.


Skills System

Rich capability advertisement for intelligent agent orchestration

The Bindu Skills System provides rich agent capability advertisement for intelligent orchestration and agent discovery. Inspired by Claude's skills architecture, it enables agents to provide detailed documentation about their capabilities for orchestrators to make informed routing decisions.

💡 What are Skills?

Skills in Bindu serve as rich advertisement metadata that help orchestrators:

  • 🔍 Discover the right agent for a task
  • 📖 Understand detailed capabilities and limitations
  • ✅ Validate requirements before execution
  • 📊 Estimate performance and resource needs
  • 🔗 Chain multiple agents intelligently

Note: Skills are not executable code—they're structured metadata that describe what your agent can do.

📋 Complete Skill Structure

View complete skill.yaml structure (click to expand)

A skill.yaml file contains all metadata needed for intelligent orchestration:

# Basic Metadata
id: pdf-processing-v1
name: pdf-processing
version: 1.0.0
author: raahul@getbindu.com

# Description
description: |
  Extract text, fill forms, and extract tables from PDF documents.
  Handles both standard text-based PDFs and scanned documents with OCR.

# Tags and Modes
tags:
  - pdf
  - documents
  - extraction

input_modes:
  - application/pdf

output_modes:
  - text/plain
  - application/json
  - application/pdf

# Example Queries
examples:
  - "Extract text from this PDF document"
  - "Fill out this PDF form with the provided data"
  - "Extract tables from this invoice PDF"

# Detailed Capabilities
capabilities_detail:
  text_extraction:
    supported: true
    types:
      - standard
      - scanned_with_ocr
    languages:
      - eng
      - spa
    limitations: "OCR requires pytesseract and tesseract-ocr"
    preserves_formatting: true

  form_filling:
    supported: true
    field_types:
      - text
      - checkbox
      - dropdown
    validation: true

  table_extraction:
    supported: true
    table_types:
      - simple
      - complex_multi_column
    output_formats:
      - json
      - csv

# Requirements
requirements:
  packages:
    - pypdf>=3.0.0
    - pdfplumber>=0.9.0
    - pytesseract>=0.3.10
  system:
    - tesseract-ocr
  min_memory_mb: 512

# Performance Metrics
performance:
  avg_processing_time_ms: 2000
  avg_time_per_page_ms: 200
  max_file_size_mb: 50
  max_pages: 500
  concurrent_requests: 5
  memory_per_request_mb: 500
  timeout_per_page_seconds: 30

# Rich Documentation
documentation:
  overview: |
    This agent specializes in PDF document processing with support for text extraction,
    form filling, and table extraction. Handles both standard text-based PDFs and
    scanned documents (with OCR).

  use_cases:
    when_to_use:
      - User uploads a PDF and asks to extract text
      - User needs to fill out PDF forms programmatically
      - User wants to extract tables from reports/invoices
    when_not_to_use:
      - PDF editing or modification
      - PDF creation from scratch
      - Image extraction from PDFs

  input_structure: |
    {
      "file": "base64_encoded_pdf_or_url",
      "operation": "extract_text|fill_form|extract_tables",
      "options": {
        "ocr": true,
        "language": "eng"
      }
    }

  output_format: |
    {
      "success": true,
      "pages": [{"page_number": 1, "text": "...", "confidence": 0.98}],
      "metadata": {"total_pages": 10, "processing_time_ms": 1500}
    }

  error_handling:
    - "Encrypted PDFs: Returns error requesting password"
    - "Corrupted files: Returns validation error with details"
    - "Timeout: 30s per page, returns partial results"

  examples:
    - title: "Extract Text from PDF"
      input:
        file: "https://example.com/document.pdf"
        operation: "extract_text"
      output:
        success: true
        pages:
          - page_number: 1
            text: "Extracted text..."
            confidence: 0.99

  best_practices:
    for_developers:
      - "Check file size before processing (max 50MB)"
      - "Use OCR only when necessary (3-5x slower)"
      - "Handle errors gracefully with user-friendly messages"
    for_orchestrators:
      - "Route based on operation type (extract/fill/parse)"
      - "Consider file size for performance estimation"
      - "Chain with text-analysis for content understanding"

# Assessment fields for skill negotiation
assessment:
  keywords:
    - pdf
    - extract
    - document
    - form
    - table

  specializations:
    - domain: invoice_processing
      confidence_boost: 0.3
    - domain: form_filling
      confidence_boost: 0.3

  anti_patterns:
    - "pdf editing"
    - "pdf creation"
    - "merge pdf"

  complexity_indicators:
    simple:
      - "single page"
      - "extract text"
    medium:
      - "multiple pages"
      - "fill form"
    complex:
      - "scanned document"
      - "ocr"
      - "batch processing"

🔌 API Endpoints

List All Skills:

GET /agent/skills

Get Skill Details:

GET /agent/skills/{skill_id}

Get Skill Documentation:

GET /agent/skills/{skill_id}/documentation

📚 See the Skills Documentation for complete examples.


Negotiation

Capability-based agent selection for intelligent orchestration

Bindu's negotiation system enables orchestrators to query multiple agents and intelligently select the best one for a task based on skills, performance, load, and cost.

🔄 How It Works

  1. Orchestrator broadcasts assessment request to multiple agents
  2. Agents self-assess capability using skill matching and load analysis
  3. Orchestrator ranks responses using multi-factor scoring
  4. Best agent selected and task executed

🔌 Assessment Endpoint

View API details (click to expand) 
POST /agent/negotiation

Request:

{
  "task_summary": "Extract tables from PDF invoices",
  "task_details": "Process invoice PDFs and extract structured data",
  "input_mime_types": ["application/pdf"],
  "output_mime_types": ["application/json"],
  "max_latency_ms": 5000,
  "max_cost_amount": "0.001",
  "min_score": 0.7,
  "weights": {
    "skill_match": 0.6,
    "io_compatibility": 0.2,
    "performance": 0.1,
    "load": 0.05,
    "cost": 0.05
  }
}

Response:

{
  "accepted": true,
  "score": 0.89,
  "confidence": 0.95,
  "skill_matches": [
    {
      "skill_id": "pdf-processing-v1",
      "skill_name": "pdf-processing",
      "score": 0.92,
      "reasons": [
        "semantic similarity: 0.95",
        "tags: pdf, tables, extraction",
        "capabilities: text_extraction, table_extraction"
      ]
    }
  ],
  "matched_tags": ["pdf", "tables", "extraction"],
  "matched_capabilities": ["text_extraction", "table_extraction"],
  "latency_estimate_ms": 2000,
  "queue_depth": 2,
  "subscores": {
    "skill_match": 0.92,
    "io_compatibility": 1.0,
    "performance": 0.85,
    "load": 0.90,
    "cost": 1.0
  }
}

📊 Scoring Algorithm

Agents calculate a confidence score based on multiple factors:

score = (
    skill_match * 0.6 +        # Primary: skill matching
    io_compatibility * 0.2 +   # Input/output format support
    performance * 0.1 +        # Speed and reliability
    load * 0.05 +              # Current availability
    cost * 0.05                # Pricing
)

🎯 Skill Assessment

View assessment metadata example (click to expand)

Skills include assessment metadata for intelligent matching:

assessment:
  keywords:
    - pdf
    - extract
    - table
    - invoice
  
  specializations:
    - domain: invoice_processing
      confidence_boost: 0.3
    - domain: table_extraction
      confidence_boost: 0.2
  
  anti_patterns:
    - "pdf editing"
    - "pdf creation"
  
  complexity_indicators:
    simple:
      - "single page"
      - "extract text"
    complex:
      - "scanned document"
      - "batch processing"

💡 Example: Multi-Agent Selection

# Query 10 translation agents
for agent in translation-agents:
  curl http://$agent:3773/agent/negotiation \
    -d '{"task_summary": "Translate technical manual to Spanish"}'

# Responses ranked by orchestrator
# Agent 1: score=0.98 (technical specialist, queue=2)
# Agent 2: score=0.82 (general translator, queue=0)
# Agent 3: score=0.65 (no technical specialization)

⚙️ Configuration

View configuration example (click to expand)

Enable negotiation in your agent config:

config = {
    "author": "your.email@example.com",
    "name": "research_agent",
    "description": "A research assistant agent",
    "deployment": {"url": "http://localhost:3773", "expose": True},
    "skills": ["skills/question-answering", "skills/pdf-processing"],
    "storage": {
        "type": "postgres",
        "database_url": "postgresql+asyncpg://bindu:bindu@localhost:5432/bindu",  # pragma: allowlist secret
        "run_migrations_on_startup": False,
    },
    "negotiation": {
        "embedding_api_key": os.getenv("OPENROUTER_API_KEY"),  # Load from environment
    },
}

📚 See the Negotiation Documentation for complete details.


Task Feedback and DSPy

Bindu collects user feedback on task executions to enable continuous improvement through DSPy optimization. By storing feedback with ratings and metadata, you can build golden datasets from real interactions and use DSPy to automatically optimize your agent's prompts and behavior.

Submitting Feedback

Provide feedback on any task using the tasks/feedback method:

curl --location 'http://localhost:3773/' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer <your-token>' \
--data '{
    "jsonrpc": "2.0",
    "method": "tasks/feedback",
    "params": {
        "taskId": "550e8400-e29b-41d4-a716-446655440200",
        "feedback": "Great job! The response was very helpful and accurate.",
        "rating": 5,
        "metadata": {
            "category": "quality",
            "source": "user",
            "helpful": true
        }
    },
    "id": "550e8400-e29b-41d4-a716-446655440024"
}'

Feedback is stored in the task_feedback table and can be used to:

  • Filter high-quality task interactions for training data
  • Identify patterns in successful vs. unsuccessful completions
  • Optimize agent instructions and few-shot examples with DSPy
  • We are working on the DsPY - will release soon.

🎨 Chat UI

Bindu includes a beautiful chat interface at http://localhost:3773/docs

Bindu Agent UI


🌐 Bindu Directory

The Bindu Directory is a public registry of all Bindu agents, making them discoverable and accessible to the broader agent ecosystem.

✨ Automatic Registration with Cookiecutter

When you create an agent using the cookiecutter template, it includes a pre-configured GitHub Action that automatically registers your agent in the directory:

  1. Create your agent using cookiecutter
  2. Push to GitHub - The GitHub Action triggers automatically
  3. Your agent appears in the Bindu Directory

🔑 Note: You need to collect the BINDU_PAT_TOKEN from bindus.directory and use it to register your agent.

📝 Manual Registration

We are working on a manual registration process.


🌌 The Vision

a peek into the night sky
}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
{{            +             +                  +   @          {{
}}   |                *           o     +                .    }}
{{  -O-    o               .               .          +       {{
}}   |                    _,.-----.,_         o    |          }}
{{           +    *    .-'.         .'-.          -O-         {{
}}      *            .'.-'   .---.   `'.'.         |     *    }}
{{ .                /_.-'   /     \   .'-.\.                   {{
}}         ' -=*<  |-._.-  |   @   |   '-._|  >*=-    .     + }}
{{ -- )--           \`-.    \     /    .-'/                   }}
}}       *     +     `.'.    '---'    .'.'    +       o       }}
{{                  .  '-._         _.-'  .                   }}
}}         |               `~~~~~~~`       - --===D       @   }}
{{   o    -O-      *   .                  *        +          {{
}}         |                      +         .            +    }}
{{ jgs          .     @      o                        *       {{
}}       o                          *          o           .  }}
{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{

Each symbol is an agent — a spark of intelligence. The tiny dot is Bindu, the origin point in the Internet of Agents.

NightSky Connection [In Progress]

NightSky enables swarms of agents. Each Bindu is a dot annotating agents with the shared language of A2A, AP2, and X402. Agents can be hosted anywhere—laptops, clouds, or clusters—yet speak the same protocol, trust each other by design, and work together as a single, distributed mind.

💭 A Goal Without a Plan Is Just a Wish.


🛠️ Supported Agent Frameworks

Bindu is framework-agnostic and tested with:

  • Agno
  • CrewAI
  • LangChain
  • LlamaIndex
  • FastAgent

Want integration with your favorite framework? Let us know on Discord!


🧪 Testing

Bindu maintains 70%+ test coverage:

pytest -n auto --cov=bindu --cov-report= && coverage report --skip-covered --fail-under=70

Troubleshooting

Common Issues
Issue Solution
Python 3.12 not found Install Python 3.12+ and set in PATH, or use pyenv
bindu: command not found Activate virtual environment: source .venv/bin/activate
Port 3773 already in use Change port in config: "url": "http://localhost:4000"
Pre-commit fails Run pre-commit run --all-files
Tests fail Install dev dependencies: uv sync --dev
Permission denied (macOS) Run xattr -cr . to clear extended attributes

Reset environment:

rm -rf .venv
uv venv --python 3.12.9
uv sync --dev

Windows PowerShell:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

🤝 Contributing

We welcome contributions! Join us on Discord. Pick the channel that best matches your contribution.

git clone https://github.com/getbindu/Bindu.git
cd Bindu
uv venv --python 3.12.9
source .venv/bin/activate
uv sync --dev
pre-commit run --all-files

📖 Contributing Guidelines


📜 License

Bindu is open-source under the Apache License 2.0.


💬 Community

We 💛 contributions! Whether you're fixing bugs, improving documentation, or building demos—your contributions make Bindu better.


🙏 Acknowledgements

Grateful to these projects:


🗺️ Roadmap

  • GRPC transport support
  • Sentry error tracking
  • Ag-UI integration
  • Retry mechanism
  • Increase test coverage to 80% - In progress
  • Redis scheduler implementation
  • Postgres database for memory storage
  • Negotiation support
  • AP2 end-to-end support
  • DSPy integration - In progress
  • MLTS support
  • X402 support with other facilitators

💡 Suggest features on Discord!


🎓 Workshops


⭐ Star History

Star History Chart

Built with 💛 by the team from Amsterdam
Happy Bindu! 🌻🚀✨

From idea to Internet of Agents in 2 minutes.
Your agent. Your framework. Universal protocols.

⭐ Star us on GitHub • 💬 Join Discord • 🌻 Read the Docs

About

Bindu: Turn any AI agent into a living microservice - interoperable, observable, composable.

docs.getbindu.com

Topics

machine-learning autonomous-agents a2a agent-communication ai-agent agent-orchestration

Resources

Readme

Contributing

Contributing
Activity
Custom properties

Stars

277 stars

Watchers

2 watching

Forks

53 forks
Report repository

Releases

37 tags

Contributors 12

Languages