Praxis

https://docs.prxs.ai
Admin
Praxis is a peer-to-peer mesh network where autonomous AI agents discover, communicate, and...
Tokens:94,041
Snippets:1,026
Trust Score:5.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Praxis Python Client

Source: https://docs.prxs.ai/py-sdk/api-reference

Install the Praxis Python client library using pip.

```bash
pip install praxis-client
```

--------------------------------

### Network Configuration Example

Source: https://docs.prxs.ai/explorer/blockchain-integration

Example configuration for Sepolia and Mainnet in YAML format, specifying chain IDs, RPC URLs, contract addresses, and indexing parameters.

```yaml
networks:
  - name: "sepolia"
    chain_id: 11155111
    rpc_url: "${SEPOLIA_RPC}"
    contracts:
      identity: "0x1234567890123456789012345678901234567890"
      reputation: "0x2345678901234567890123456789012345678901"
      registry: "0x3456789012345678901234567890123456789012"
    start_block: 4000000
    poll_interval: "12s"
    batch_size: 100
    max_reorg_depth: 64
    reorg_buffer: 12

  - name: "mainnet"
    chain_id: 1
    rpc_url: "${MAINNET_RPC}"
    contracts:
      identity: "0x4567890123456789012345678901234567890123"
      reputation: "0x5678901234567890123456789012345678901234"
      registry: "0x6789012345678901234567890123456789012345"
    start_block: 18000000
    poll_interval: "12s"
    batch_size: 100
    max_reorg_depth: 64
    reorg_buffer: 12

```

--------------------------------

### Start Backend Agents with Docker Compose

Source: https://docs.prxs.ai/getting-started/no-code-builder/quickstart

Use Docker Compose to start the backend agents for the Go SDK. Ensure you are in the correct directory.

```bash
cd praxis-go-sdk
docker-compose up -d
```

--------------------------------

### Get Task Details Response Example

Source: https://docs.prxs.ai/go-sdk/api-reference

An example of the JSON response when retrieving detailed information about a specific task.

```json
{
  "id": "task-789",
  "context_id": "ctx-456",
  "status": {
    "state": "completed",
    "timestamp": "2024-01-15T10:30:05Z",
    "message": {
      "role": "assistant",
      "content": "Task completed successfully"
    }
  },
  "history": [
    {
      "role": "user",
      "content": "Execute write_file tool",
      "timestamp": "2024-01-15T10:30:00Z"
    },
    {
      "role": "assistant",
      "content": "File written successfully",
      "timestamp": "2024-01-15T10:30:05Z"
    }
  ],
  "artifacts": []
}
```

--------------------------------

### Complete Workflow Example using cURL and jq

Source: https://docs.prxs.ai/go-sdk/api-reference

A multi-step example demonstrating how to execute a workflow, monitor it via WebSocket, check its status, and list all workflows using command-line tools.

```bash
# 1. Execute workflow
WORKFLOW_ID=$(curl -s -X POST http://localhost:8000/execute 
  -H "Content-Type: application/json" 
  -d '{"query": "create a file with JSON data"}' | jq -r '.workflow_id')

# 2. Monitor via WebSocket
wscat -c ws://localhost:9000/ws/workflow

# 3. Check status
curl http://localhost:8000/workflow/$WORKFLOW_ID

# 4. List all workflows
curl http://localhost:8000/workflows
```

--------------------------------

### List Agents cURL Example

Source: https://docs.prxs.ai/explorer/api-reference

Command-line example using cURL to fetch a list of agents with specified network and limit.

```bash
curl "http://localhost:8080/api/agents?network=sepolia&limit=5"
```

--------------------------------

### Tool Node Configuration Example

Source: https://docs.prxs.ai/no-code-builder/node-types

Example configuration for a Tool node, including its ID, name, parameter definitions, input mapping from a previous node, and output mapping to extract specific results.

```yaml
type: tool
data:
  toolId: "tool-sentiment-001"
  toolName: "sentiment_analysis"
  parameters:
    text:
      type: "string"
      required: true
    language:
      type: "string"
      default: "en"
  inputMapping:
    text: "{{agent.output}}"
  outputMapping:
    result: "$.sentiment"
```

--------------------------------

### Handoff Node Example Configuration

Source: https://docs.prxs.ai/no-code-builder/node-types

An example configuration for a handoff node, specifying the target agent, a condition for the handoff, context data to pass, and a timeout.

```yaml
type: handoff
data:
  targetAgent: "specialist-agent-002"
  condition: "output.requiresSpecialist === true"
  context:
    taskType: "detailed-analysis"
    previousResults: "{{agent.output}}"
  timeout: 30000
```

--------------------------------

### Agent Node Configuration Example

Source: https://docs.prxs.ai/no-code-builder/node-types

Example configuration for an Agent node, specifying its ID, name, LLM model, temperature, max tokens, system prompt, and available tools.

```yaml
type: agent
data:
  agentId: "agent-001"
  name: "Customer Feedback Analyzer"
  model: "gpt-4"
  temperature: 0.7
  maxTokens: 1024
  systemPrompt: "You are a customer feedback analysis expert..."
  tools:
    - "sentiment_analysis"
    - "theme_extraction"
```

--------------------------------

### Start Services with Docker Compose

Source: https://docs.prxs.ai/getting-started/go-sdk/quickstart

Use Docker Compose to easily start the multi-agent network. This command initiates the orchestrator, tool agents, and WebSocket server.

```bash
# Start the entire multi-agent network
docker-compose up -d

# View logs
docker-compose logs -f

# Stop all services
docker-compose down
```

--------------------------------

### Start Explorer Services with Docker Compose

Source: https://docs.prxs.ai/getting-started/explorer/quickstart

Build and start all necessary Explorer services using Docker Compose. The frontend, API, and database will be accessible on specified ports.

```bash
# Start all services
docker-compose up --build

# Services will be available at:
# - Frontend: http://localhost:3100
# - API: http://localhost:8080
# - Database: PostgreSQL on localhost:5432
```

--------------------------------

### File Operations Workflow Example

Source: https://docs.prxs.ai/getting-started/go-sdk/quickstart

Execute a file operations workflow using the DSL. This example demonstrates calling `write_file` to create a report and then `read_file` to verify its content.

```bash
curl -X POST http://localhost:8000/execute 
  -H "Content-Type: application/json" 
  -d '{
    "dsl": "CALL write_file report.txt \"Sales Report\" && CALL read_file report.txt"
  }'
```

--------------------------------

### Gin HTTP Server Setup

Source: https://docs.prxs.ai/explorer/architecture

Defines the HTTP server structure and the setup for API routes using the Gin framework. Includes endpoints for health checks, agents, and networks.

```go
type Server struct {
    router  *gin.Engine
    store   store.Store
    indexer *indexer.Indexer
    config  *Config
}

func (s *Server) setupRoutes() {
    // Health check
    s.router.GET("/health", s.handleHealth)

    // API routes
    api := s.router.Group("/api")
    {
        // Agent endpoints
        api.GET("/agents", s.handleListAgents)
        api.GET("/agents/:id", s.handleGetAgent)

        // Network endpoints
        api.GET("/networks", s.handleListNetworks)
        api.GET("/networks/:id/agents", s.handleListNetworkAgents)
    }
}
```

--------------------------------

### Start Orchestrator with Python SDK

Source: https://docs.prxs.ai/no-code-builder/integration

Commands to configure and start the orchestrator using the Praxis Python SDK. Requires Poetry for environment management.

```bash
cd praxis-py-sdk

# Configure
export PRAXIS_AGENT_ID=orchestrator
export PRAXIS_HTTP_PORT=8000
export PRAXIS_WS_PORT=8090

# Start
poetry run python -m praxis_sdk.main
```

--------------------------------

### Agent User Prompt Template Example

Source: https://docs.prxs.ai/no-code-builder/node-types

Example of a user prompt template for an Agent node, including a variable for dynamic input.

```text
Analyze this feedback: {{input.text}}
Extract sentiment and main concerns.
```

--------------------------------

### List Agents JavaScript Example

Source: https://docs.prxs.ai/explorer/api-reference

JavaScript example using the fetch API to retrieve a list of agents and log their data.

```javascript
const response = await fetch(
  'http://localhost:8080/api/agents?network=sepolia&limit=5'
);
const data = await response.json();
console.log(data.agents);
```

--------------------------------

### Clone and Set Up Development Environment

Source: https://docs.prxs.ai/getting-started/contributing

Steps to fork, clone the repository, install dependencies, and create a feature branch for development.

```bash
# Fork and clone the repository
git clone https://github.com/your-username/repo-name
cd repo-name

# Install dependencies
poetry install  # For Python projects
npm install     # For docs projects (if applicable)

# Create a feature branch
git checkout -b feature/your-feature-name
```

--------------------------------

### Install Project with Poetry

Source: https://docs.prxs.ai/getting-started/python-sdk/quickstart

Installs the project dependencies in editable mode. Allows for direct code changes and testing without reinstallation.

```bash
poetry install
```

--------------------------------

### Start Orchestrator Agent with Go SDK

Source: https://docs.prxs.ai/no-code-builder/integration

Commands to configure and start the orchestrator agent using the Praxis Go SDK. Ensure environment variables are set before running.

```bash
cd praxis-go-sdk

# Configure agent
export PRAXIS_AGENT_ID=orchestrator
export PRAXIS_HTTP_PORT=8000
export PRAXIS_WS_PORT=8090
export OPENAI_API_KEY=your_key

# Start agent
go run cmd/agent/main.go
```

--------------------------------

### Agent System Prompt Example

Source: https://docs.prxs.ai/no-code-builder/node-types

Example of a system prompt for an Agent node, defining its role and specialization in data analysis.

```text
You are a helpful data analysis agent specialized in extracting
insights from customer feedback. Focus on sentiment and key themes.
```

--------------------------------

### PraxisAgent Initialization and Start

Source: https://docs.prxs.ai/py-sdk/architecture

Initializes the PraxisAgent with configuration and starts its subsystems using Trio's structured concurrency. Manages agent lifecycle and coordinates services via the EventBus.

```python
class PraxisAgent:
    def __init__(self, config: AgentConfig):
        self.config = config
        self.peer_id: Optional[str] = None
        self.host: Optional[Host] = None

        # Services
        self.event_bus = EventBus()
        self.p2p_service: Optional[P2PService] = None
        self.mcp_service: Optional[MCPService] = None
        self.api_server: Optional[APIServer] = None
        self.a2a_protocol: Optional[A2AProtocol] = None

        # Execution
        self.tool_registry = ToolRegistry()
        self.engine_manager = ExecutionEngineManager()

        # Storage
        self.storage = EncryptedKVStore(config.storage)

        # Monitoring
        self.metrics = PrometheusMetrics()

    async def start(self):
        """Start agent with structured concurrency."""
        async with trio.open_nursery() as nursery:
            self._nursery = nursery

            # Start services
            nursery.start_soon(self._start_p2p)
            nursery.start_soon(self._start_api)
            nursery.start_soon(self._start_mcp)
            nursery.start_soon(self._start_monitoring)

            # Wait for shutdown signal
            await self._wait_for_shutdown()
```

--------------------------------

### Local Development Commands

Source: https://docs.prxs.ai/getting-started/faq

Install dependencies and run your agent locally using Poetry.

```bash
poetry install
poetry run serve run entrypoint:app
```

--------------------------------

### Praxis Client Library Usage

Source: https://docs.prxs.ai/py-sdk/api-reference

This snippet demonstrates how to install the Praxis client library and use it to connect to the agent, create and stream workflows, get workflow results, and list connected peers.

```APIDOC
## Python Client Library

### Installation
```
pip install praxis-client
```

### Usage
```python
from praxis.client import PraxisClient
import asyncio

async def main():
    # Connect to agent
    client = PraxisClient("http://localhost:8000")

    # Create workflow
    workflow = await client.create_workflow(
        prompt="create a file with data"
    )
    print(f"Workflow ID: {workflow.id}")

    # Stream events
    async for event in client.stream_workflow(workflow.id):
        print(f"Event: {event.type}")

    # Get result
    result = await client.get_workflow(workflow.id)
    print(f"Status: {result.status}")

    # List peers
    peers = await client.list_peers()
    print(f"Connected peers: {len(peers)}")

asyncio.run(main())
```
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://docs.prxs.ai/getting-started/python-sdk/quickstart

Clone the Praxis Python SDK repository and install its dependencies using Poetry. Ensure you have Python 3.11+ and Poetry installed.

```bash
git clone https://github.com/prxs-ai/praxis-py-sdk
cd praxis-py-sdk
```

```bash
# Install Poetry if needed
curl -sSL https://install.python-poetry.org | python3 -

# Install project dependencies
poetry install
```

--------------------------------

### Start Tool Agent with Python SDK

Source: https://docs.prxs.ai/no-code-builder/integration

Command to start a tool agent using the Praxis Python SDK. Ensure the PRAXIS_AGENT_ID and PRAXIS_HTTP_PORT are set.

```bash
export PRAXIS_AGENT_ID=tool-agent-1
export PRAXIS_HTTP_PORT=8001

poetry run python -m praxis_sdk.main
```

--------------------------------

### Start Tool Agents with Go SDK

Source: https://docs.prxs.ai/no-code-builder/integration

Commands to start multiple tool agents using the Praxis Go SDK. Each agent requires a unique PRAXIS_AGENT_ID and HTTP port.

```bash
# Agent 1
export PRAXIS_AGENT_ID=tool-agent-1
export PRAXIS_HTTP_PORT=8001
go run cmd/agent/main.go

# Agent 2
export PRAXIS_AGENT_ID=tool-agent-2
export PRAXIS_HTTP_PORT=8002
go run cmd/agent/main.go
```

--------------------------------

### Start Docker Compose Services

Source: https://docs.prxs.ai/no-code-builder/integration

Command to start all services defined in the docker-compose.yml file in detached mode.

```bash
docker-compose up -d
```

--------------------------------

### Agent Configuration Example

Source: https://docs.prxs.ai/getting-started/python-sdk/quickstart

This is an example configuration for the orchestrator agent, detailing settings for agent identity, P2P networking, MCP, API, LLM, storage, and metrics.

```yaml
agent:
  id: "orchestrator"
  name: "Orchestrator Agent"
  description: "Main coordination agent"

p2p:
  listen_port: 4001
  enable_mdns: true
  enable_dht: true
  bootstrap_peers: []

mcp:
  server_port: 3000
  transport: "sse"
  tools:
    - name: "file_operations"
      enabled: true
    - name: "data_processing"
      enabled: true

api:
  http_port: 8000
  enable_websocket: true
  websocket_port: 8090

llm:
  provider: "openai"
  model: "gpt-4"
  temperature: 0.7
  max_tokens: 2048

storage:
  type: "encrypted_kv"
  encryption_key: "${STORAGE_ENCRYPTION_KEY}"
  backend: "sqlite"
  path: "data/agent.db"

metrics:
  enabled: true
  prometheus_port: 9090
```

--------------------------------

### Start No-Code Builder with Docker Compose

Source: https://docs.prxs.ai/getting-started/no-code-builder/quickstart

Clone the No-Code Builder repository and use Docker Compose to start the application locally. Access it via http://localhost:3000.

```bash
git clone https://github.com/prxs-ai/praxis-nocode-builder
cd praxis-nocode-builder

# Start with Docker
docker-compose up -d

# Access at http://localhost:3000
```

--------------------------------

### Conditional Node Example Configuration

Source: https://docs.prxs.ai/no-code-builder/node-types

An example configuration for a conditional node, specifying a condition, labels for true/false outcomes, and the target branches for each outcome.

```yaml
type: conditional
data:
  condition: "sentiment === 'negative' && score < 0.3"
  trueLabel: "Escalate to Human"
  falseLabel: "Continue Processing"
  branches:
    true: "handoff-to-human"
    false: "continue-workflow"
```

--------------------------------

### Go SDK - List Peers

Source: https://docs.prxs.ai/go-sdk/api-reference

Example of how to list peers using the Praxis Go SDK.

```go
import "github.com/praxis/praxis-go-sdk/pkg/client"

client := client.NewPraxisClient("http://localhost:8000")

// List peers
peers, err := client.ListPeers(ctx)
```

--------------------------------

### Multi-Agent Tool Invocation Example

Source: https://docs.prxs.ai/go-sdk/api-reference

Demonstrates how to discover peer capabilities and execute a tool on a remote agent using cURL.

```bash
# 1. Get peer capabilities
curl http://localhost:8000/p2p/cards | jq '.cards[].tools[].name'

# 2. Execute tool on remote agent
curl -X POST http://localhost:8000/execute 
  -H "Content-Type: application/json" 
  -d '{
    "dsl": "CALL @peer:12D3KooW.../process_data input.txt"
  }'
```

--------------------------------

### Install Poetry and Set PATH

Source: https://docs.prxs.ai/getting-started/python-sdk/quickstart

Installs Poetry using a curl script and updates the PATH environment variable. Add the export command to your shell profile for persistence.

```bash
curl -sSL https://install.python-poetry.org | python3 -
export PATH="$HOME/.local/bin:$PATH"

# Add to .bashrc or .zshrc for persistence
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
```

--------------------------------

### Example: File Writer Tool Contract

Source: https://docs.prxs.ai/py-sdk/tools-and-execution

An example of a concrete tool contract for a file writer, specifying input/output schemas and execution details. This contract is designed for the local execution engine.

```python
file_writer_contract = ToolContract(
    name="write_file",
    description="Write content to a file in the workspace",
    version="1.0.0",
    category="file_operations",
    tags=["io", "filesystem"],

    input_schema={
        "type": "object",
        "properties": {
            "filename": {
                "type": "string",
                "description": "Name of the file to create"
            },
            "content": {
                "type": "string",
                "description": "Content to write to the file"
            },
            "mode": {
                "type": "string",
                "enum": ["write", "append"],
                "default": "write",
                "description": "Write mode"
            }
        },
        "required": ["filename", "content"]
    },

    output_schema={
        "type": "object",
        "properties": {
            "success": {"type": "boolean"},
            "bytes_written": {"type": "integer"},
            "filepath": {"type": "string"}
        },
        "required": ["success"]
    },

    execution_engine="local",
    module="praxis.tools.file",
    function="write_file",
    requires_filesystem=True,
    timeout_seconds=30
)
```

--------------------------------

### Go SDK - Execute Workflow

Source: https://docs.prxs.ai/go-sdk/api-reference

Example of how to execute a workflow using the Praxis Go SDK.

```go
import "github.com/praxis/praxis-go-sdk/pkg/client"

client := client.NewPraxisClient("http://localhost:8000")

// Execute workflow
result, err := client.Execute(ctx, "CALL write_file test.txt \"data\"")
```

--------------------------------

### Configure Agent Node

Source: https://docs.prxs.ai/no-code-builder/workflows

Example configuration for an agent node, specifying its name, type, model, temperature, and system prompt.

```yaml
name: "Data Analyzer"
type: agent
model: gpt-4
temperature: 0.7
systemPrompt: "You are a data analysis expert..."
```

--------------------------------

### Start Praxis Agent with Docker Compose

Source: https://docs.prxs.ai/getting-started/python-sdk/quickstart

Use Docker Compose to start the multi-agent network, including the orchestrator, tool agents, PostgreSQL, and Redis. View logs with `docker-compose logs -f praxis-orchestrator` and stop services with `docker-compose down`.

```bash
# Start the entire multi-agent network
docker-compose up -d

# View logs
docker-compose logs -f praxis-orchestrator

# Stop all services
docker-compose down
```

--------------------------------

### Get Praxis Metrics with cURL

Source: https://docs.prxs.ai/py-sdk/api-reference

Use cURL to fetch all metrics exposed by the Praxis agent and filter for those starting with 'praxis_'.

```bash
curl http://localhost:9090/metrics | grep praxis_
```

--------------------------------

### Run Agent with File Watching

Source: https://docs.prxs.ai/getting-started/python-sdk/quickstart

Starts the Praxis agent and automatically restarts it when source files change. Requires `entr` to be installed.

```bash
find src | entr -r poetry run praxis-agent run --config configs/orchestrator.yaml
```

--------------------------------

### Go SDK: Initialize Agent

Source: https://docs.prxs.ai/core-concepts/agents

Initialize a new agent using the Go SDK. Configure the agent with its name, DID, and capabilities.

```go
// Go SDK
import "github.com/praxis/agent"

praxisAgent := agent.NewPraxisAgent(
    agent.WithName("my-agent"),
    agent.WithDID("did:web:example.com:agents:my-agent"),
    agent.WithCapabilities([]string{"data_processing", "api_integration"}),
)

praxisAgent.Start()
```

--------------------------------

### Build and Run the Agent

Source: https://docs.prxs.ai/getting-started/go-sdk/quickstart

Compile the agent binary using `go build` and then run the executable. This is part of the development workflow for building and deploying the agent.

```bash
# Build binary
go build -o bin/praxis-agent cmd/agent/main.go

# Run the binary
./bin/praxis-agent
```

--------------------------------

### Workflow Start Event

Source: https://docs.prxs.ai/no-code-builder/integration

JSON structure for signaling the start of a workflow.

```json
{
  "type": "WORKFLOW_START",
  "data": {
    "workflowId": "wf-abc123",
    "timestamp": "2024-01-15T10:30:00Z"
  }
}
```

--------------------------------

### List Agents Request with Pagination

Source: https://docs.prxs.ai/explorer/api-reference

Example HTTP request to list agents with specified network, limit, and offset parameters.

```http
GET /api/agents?network=sepolia&limit=20&offset=40 HTTP/1.1
```

--------------------------------

### Get Workflow Status

Source: https://docs.prxs.ai/py-sdk/api-reference

Get detailed status and results of a workflow.

```APIDOC
## GET /api/workflows/{workflow_id}

### Description
Get detailed status and results of a workflow.

### Method
GET

### Endpoint
/api/workflows/{workflow_id}

### Parameters
#### Path Parameters
- **workflow_id** (string) - Required - The ID of the workflow to retrieve.

### Response
#### Success Response (200)
- **workflow_id** (string) - Unique identifier for the workflow.
- **status** (string) - Current status of the workflow (e.g., completed).
- **created_at** (string) - Timestamp when the workflow was created.
- **started_at** (string) - Timestamp when the workflow started execution.
- **completed_at** (string) - Timestamp when the workflow completed execution.
- **duration_ms** (integer) - Total duration of the workflow in milliseconds.
- **steps** (array) - List of steps executed in the workflow.
  - **id** (string) - Identifier for the step.
  - **status** (string) - Status of the step.
  - **result** (object) - Result of the step execution.
  - **duration_ms** (integer) - Duration of the step in milliseconds.
- **artifacts** (array) - List of artifacts generated by the workflow.
  - **name** (string) - Name of the artifact.
  - **type** (string) - Type of the artifact (e.g., file).
  - **uri** (string) - URI to access the artifact.
  - **size_bytes** (integer) - Size of the artifact in bytes.

### Response Example
```json
{
  "workflow_id": "wf-abc123",
  "status": "completed",
  "created_at": "2024-01-15T10:30:00Z",
  "started_at": "2024-01-15T10:30:01Z",
  "completed_at": "2024-01-15T10:30:05Z",
  "duration_ms": 4000,
  "steps": [
    {
      "id": "step1",
      "status": "completed",
      "result": {
        "success": true,
        "output": "File created successfully"
      },
      "duration_ms": 1200
    }
  ],
  "artifacts": [
    {
      "name": "output.txt",
      "type": "file",
      "uri": "/workspace/output.txt",
      "size_bytes": 1024
    }
  ]
}
```
```

--------------------------------

### Go SDK Client Initialization and Usage

Source: https://docs.prxs.ai/go-sdk/api-reference

Shows how to initialize the Praxis Go SDK client and use it to execute workflows and list peers.

```go
import "github.com/praxis/praxis-go-sdk/pkg/client"

client := client.NewPraxisClient("http://localhost:8000")

// Execute workflow
result, err := client.Execute(ctx, "CALL write_file test.txt \"data\"")

// List peers
peers, err := client.ListPeers(ctx)
```

--------------------------------

### Get Workflow Status

Source: https://docs.prxs.ai/go-sdk/api-reference

Get status and results of a specific workflow.

```APIDOC
## Get Workflow Status

### Description
Get status and results of a specific workflow.

### Method
GET

### Endpoint
/workflow/:id

### Response
#### Success Response (200)
- **workflow_id** (string) - The ID of the workflow.
- **status** (string) - The current status of the workflow.
- **created_at** (string) - Timestamp when the workflow was created.
- **completed_at** (string) - Timestamp when the workflow was completed.
- **nodes** (array) - An array of nodes in the workflow.
  - **id** (string) - The ID of the node.
  - **status** (string) - The status of the node.
  - **result** (object) - The result of the node execution.
    - **success** (boolean) - Indicates if the node execution was successful.
    - **output** (string) - The output of the node.

### Response Example
```json
{
  "workflow_id": "wf-123456",
  "status": "completed",
  "created_at": "2024-01-15T10:30:00Z",
  "completed_at": "2024-01-15T10:30:05Z",
  "nodes": [
    {
      "id": "node1",
      "status": "completed",
      "result": {
        "success": true,
        "output": "File written successfully"
      }
    }
  ]
}
```
```

--------------------------------

### Get Peer Capabilities

Source: https://docs.prxs.ai/go-sdk/api-reference

Get capability cards from all connected peers.

```APIDOC
## Get Peer Capabilities

### Description
Get capability cards from all connected peers.

### Method
GET

### Endpoint
/p2p/cards

### Response
#### Success Response (200)
- **cards** (array) - An array of capability cards from peers.
  - **peer_id** (string) - The ID of the peer.
  - **name** (string) - The name of the agent.
  - **version** (string) - The version of the agent.
  - **did** (string) - The Decentralized Identifier of the agent.
  - **capabilities** (array) - A list of capabilities offered by the agent.
  - **tools** (array) - A list of tools available on the agent.
    - **name** (string) - The name of the tool.
    - **description** (string) - A description of the tool.
    - **parameters** (array) - The parameters the tool accepts.
      - **name** (string) - The name of the parameter.
      - **type** (string) - The data type of the parameter.
      - **required** (boolean) - Whether the parameter is required.
  - **endpoints** (object) - Network endpoints for the agent.
    - **mcp** (string) - The MCP endpoint.
    - **http** (string) - The HTTP endpoint.

### Response Example
```json
{
  "cards": [
    {
      "peer_id": "12D3KooWAbCdEfGh...",
      "name": "praxis-agent-2",
      "version": "1.0.0",
      "did": "did:web:example.com:agent-2",
      "capabilities": ["file_operations", "data_processing"],
      "tools": [
        {
          "name": "write_file",
          "description": "Write content to a file",
          "parameters": [
            {
              "name": "filename",
              "type": "string",
              "required": true
            },
            {
              "name": "content",
              "type": "string",
              "required": true
            }
          ]
        }
      ],
      "endpoints": {
        "mcp": "http://agent-2:9000",
        "http": "http://agent-2:8001"
      }
    }
  ]
}
```
```

--------------------------------

### SQL Query Optimization with EXPLAIN ANALYZE

Source: https://docs.prxs.ai/explorer/architecture

Demonstrates how to optimize SQL queries by using `EXPLAIN ANALYZE` to identify inefficient scans and ensure index usage.

```sql
-- Use indexes for fast lookups
EXPLAIN ANALYZE
SELECT * FROM agents
WHERE network = 'sepolia'
  AND domain = 'finance'
ORDER BY reputation_score DESC
LIMIT 20;

-- Result should show Index Scan instead of Sequential Scan
```

--------------------------------

### LLM Generated Workflow Example

Source: https://docs.prxs.ai/go-sdk/architecture

An example of a workflow generated by an LLM, defining nodes and edges for task execution across agents.

```json
{
  "nodes": [
    {
      "id": "node1",
      "tool": "read_file",
      "args": {"filename": "data.txt"},
      "agent": "local"
    },
    {
      "id": "node2",
      "tool": "process_data",
      "args": {"data": "$node1.output"},
      "agent": "peer:12D3KooW..."
    }
  ],
  "edges": [
    {"from": "node1", "to": "node2"}
  ]
}
```

--------------------------------

### MCP Client Tool Discovery and Call

Source: https://docs.prxs.ai/go-sdk/architecture

Shows how to discover available tools on a remote agent and how to invoke a specific tool with arguments.

```go
// List all available tools from remote agent
tools, err := client.ListTools(serverURL)

// Call remote tool
result, err := client.CallTool(serverURL, toolName, arguments)
```

--------------------------------

### Agent Configuration File Example

Source: https://docs.prxs.ai/getting-started/go-sdk/quickstart

Configure agent settings by editing the `configs/agent.yaml` file. This includes agent identity, P2P networking, MCP settings, and LLM provider details.

```yaml
agent:
  id: "my-agent"
  name: "My Custom Agent"
  description: "A powerful Praxis agent"

p2p:
  listen_port: 4001
  enable_mdns: true
  enable_dht: true

mcp:
  server_port: 3000
  tools:
    - name: "file_operations"
      enabled: true
    - name: "data_processing"
      enabled: true

http:
  port: 8000

websocket:
  port: 8090

llm:
  provider: "openai"
  model: "gpt-4"
  api_key: "${OPENAI_API_KEY}"
```

--------------------------------

### Tool Node Input Mapping Example

Source: https://docs.prxs.ai/no-code-builder/node-types

Illustrates how to map data from previous workflow steps or agent outputs to the input parameters of a Tool node.

```yaml
inputMapping:
  text: "{{previousNode.output.feedback}}"
  language: "en"
  detailed: true
```

--------------------------------

### Build Production Bundle with npm

Source: https://docs.prxs.ai/no-code-builder/integration

Command to build the production-ready bundle for your frontend application using npm.

```bash
npm run build
```

--------------------------------

### Initialize Remote Write Client

Source: https://docs.prxs.ai/py-sdk/advanced-topics

Configure and start a client for sending metrics to a remote write endpoint. Specify the URL, collection interval, and batch size.

```python
from praxis.monitoring import RemoteWriteClient

client = RemoteWriteClient(
    url="http://prometheus:9091/api/v1/write",
    interval=15,
    batch_size=1000
)

await client.start()
```

--------------------------------

### Get Workflow Status Response

Source: https://docs.prxs.ai/go-sdk/api-reference

The response for GET /workflow/:id provides the status, creation timestamp, completion timestamp, and detailed node information for a specific workflow.

```json
{
  "workflow_id": "wf-123456",
  "status": "completed",
  "created_at": "2024-01-15T10:30:00Z",
  "completed_at": "2024-01-15T10:30:05Z",
  "nodes": [
    {
      "id": "node1",
      "status": "completed",
      "result": {
        "success": true,
        "output": "File written successfully"
      }
    }
  ]
}
```

--------------------------------

### Python SDK: Initialize Agent

Source: https://docs.prxs.ai/core-concepts/agents

Initialize a new agent using the Python SDK. Specify the agent's name, DID, and capabilities.

```python
# Python SDK
from praxis.agent import PraxisAgent

agent = PraxisAgent(
    name="my-agent",
    did="did:web:example.com:agents:my-agent",
    capabilities=["data_processing", "api_integration"]
)

await agent.start()
```

--------------------------------

### MCP Server AddTool Method

Source: https://docs.prxs.ai/go-sdk/architecture

Illustrates the method for registering a tool with the MCP server, making it available to remote agents.

```go
func (m *MCPServerWrapper) AddTool(tool *mcp.Tool, handler func) {
    // Register tool with JSON schema
    // Add to server tool list
    // Make available to remote agents
}
```

--------------------------------

### Initialize Connection Pool

Source: https://docs.prxs.ai/py-sdk/advanced-topics

Set up a connection pool for managing P2P connections. Configure minimum and maximum pool sizes, idle timeouts, and maximum connection lifetimes.

```python
from praxis.p2p import ConnectionPool

pool = ConnectionPool(
    min_size=5,
    max_size=20,
    idle_timeout=300,
    max_lifetime=3600
)

# Get connection
async with pool.acquire(peer_id) as conn:
    result = await conn.call_tool("process_data", args)
```

--------------------------------

### Get Workflow Status API Request

Source: https://docs.prxs.ai/no-code-builder/integration

Shows the GET request format for retrieving the status of a specific workflow using its ID. Includes the expected response structure with status, progress, and results.

```json
GET /api/workflow/status/{workflowId}
```

```json
{
  "workflowId": "wf-abc123",
  "status": "completed",
  "progress": 100,
  "result": {...},
  "duration": 5000
}
```

--------------------------------

### Get Workflow Status API Response

Source: https://docs.prxs.ai/py-sdk/api-reference

This GET endpoint retrieves the detailed status and results of a specific workflow using its ID. The response includes completion times, step details, and any artifacts generated.

```json
{
  "workflow_id": "wf-abc123",
  "status": "completed",
  "created_at": "2024-01-15T10:30:00Z",
  "started_at": "2024-01-15T10:30:01Z",
  "completed_at": "2024-01-15T10:30:05Z",
  "duration_ms": 4000,
  "steps": [
    {
      "id": "step1",
      "status": "completed",
      "result": {
        "success": true,
        "output": "File created successfully"
      },
      "duration_ms": 1200
    }
  ],
  "artifacts": [
    {
      "name": "output.txt",
      "type": "file",
      "uri": "/workspace/output.txt",
      "size_bytes": 1024
    }
  ]
}
```

--------------------------------

### List Available Tools

Source: https://docs.prxs.ai/py-sdk/api-reference

Lists all tools registered locally on the system. The response includes tool names, descriptions, versions, input/output schemas, and execution engine information.

```json
{
  "tools": [
    {
      "name": "write_file",
      "description": "Write content to a file",
      "version": "1.0.0",
      "input_schema": {...},
      "output_schema": {...},
      "execution_engine": "local"
    }
  ],
  "total": 15
}
```

--------------------------------

### Configure Dagger Engine

Source: https://docs.prxs.ai/py-sdk/tools-and-execution

Set up the Dagger execution engine with specific configurations for caching, network mode, and resource limits.

```python
from praxis.execution.engines import DaggerEngine

engine = DaggerEngine(
    config={
        "cache_enabled": True,
        "cache_ttl": 3600,
        "network_mode": "bridge",
        "resource_limits": {
            "cpu": "1.0",
            "memory": "512m"
        }
    }
)

await engine.initialize()
```

--------------------------------

### Get Tasks Response

Source: https://docs.prxs.ai/go-sdk/api-reference

The GET /tasks endpoint returns a list of all Asynchronous-to-Asynchronous (A2A) tasks. Each task includes its ID, context ID, status, type, and any associated artifacts like output files.

```json
{
  "tasks": [
    {
      "id": "task-789",
      "context_id": "ctx-456",
      "status": {
        "state": "completed",
        "timestamp": "2024-01-15T10:30:05Z"
      },
      "kind": "execute_tool",
      "artifacts": [
        {
          "name": "output.txt",
          "type": "file",
          "uri": "/shared/output.txt"
        }
      ]
    }
  ]
}
```

--------------------------------

### Get Agent Capabilities API Request

Source: https://docs.prxs.ai/no-code-builder/integration

Demonstrates how to fetch detailed information about a specific agent's tools and supported models using its ID via a GET request to the /api/agents/{agentId}/capabilities endpoint.

```json
GET /api/agents/{agentId}/capabilities
```

```json
{
  "agentId": "agent-001",
  "tools": [
    {
      "name": "sentiment_analysis",
      "description": "Analyze text sentiment",
      "parameters": {...}
    }
  ],
  "models": ["gpt-4", "claude-3-sonnet"]
}
```

--------------------------------

### Configure Docker SDK Engine

Source: https://docs.prxs.ai/py-sdk/tools-and-execution

Initialize the Docker SDK execution engine with connection details, auto-removal policy, pull strategy, network mode, and volume mounts.

```python
from praxis.execution.engines import DockerSDKEngine

engine = DockerSDKEngine(
    config={
        "docker_url": "unix:///var/run/docker.sock",
        "auto_remove": True,
        "pull_policy": "if_not_present",
        "network_mode": "bridge",
        "volumes": {
            "/workspace": {"bind": "/workspace", "mode": "rw"}
        }
    }
)
```

--------------------------------

### Get Peer Capabilities Response

Source: https://docs.prxs.ai/go-sdk/api-reference

This response from the GET /p2p/cards endpoint details the capabilities, tools, and API endpoints of connected peers. It includes information like peer ID, name, version, DID, and available tools with their parameters.

```json
{
  "cards": [
    {
      "peer_id": "12D3KooWAbCdEfGh...",
      "name": "praxis-agent-2",
      "version": "1.0.0",
      "did": "did:web:example.com:agent-2",
      "capabilities": ["file_operations", "data_processing"],
      "tools": [
        {
          "name": "write_file",
          "description": "Write content to a file",
          "parameters": [
            {
              "name": "filename",
              "type": "string",
              "required": true
            },
            {
              "name": "content",
              "type": "string",
              "required": true
            }
          ]
        }
      ],
      "endpoints": {
        "mcp": "http://agent-2:9000",
        "http": "http://agent-2:8001"
      }
    }
  ]
}
```

--------------------------------

### Get Tasks

Source: https://docs.prxs.ai/go-sdk/api-reference

List all A2A tasks.

```APIDOC
## Get Tasks

### Description
List all A2A tasks.

### Method
GET

### Endpoint
/tasks

### Response
#### Success Response (200)
- **tasks** (array) - An array of task objects.
  - **id** (string) - The ID of the task.
  - **context_id** (string) - The context ID of the task.
  - **status** (object) - The status of the task.
    - **state** (string) - The current state of the task.
    - **timestamp** (string) - The timestamp of the status update.
  - **kind** (string) - The type of task.
  - **artifacts** (array) - An array of artifacts produced by the task.
    - **name** (string) - The name of the artifact.
    - **type** (string) - The type of the artifact.
    - **uri** (string) - The URI of the artifact.

### Response Example
```json
{
  "tasks": [
    {
      "id": "task-789",
      "context_id": "ctx-456",
      "status": {
        "state": "completed",
        "timestamp": "2024-01-15T10:30:05Z"
      },
      "kind": "execute_tool",
      "artifacts": [
        {
          "name": "output.txt",
          "type": "file",
          "uri": "/shared/output.txt"
        }
      ]
    }
  ]
}
```
```

--------------------------------

### Prepare Git Repository for Release

Source: https://docs.prxs.ai/getting-started/faq

Use these commands to stage, commit, and push your changes before triggering a release workflow.

```bash
git add .
git commit -m "Ready for release"
git push
```

--------------------------------

### Agent Collaboration Workflow Example

Source: https://docs.prxs.ai/no-code-builder/workflows

Illustrates a multi-agent workflow for research and analysis. Use for complex tasks requiring sequential agent processing.

```text
Workflow: Research Team
├── Researcher Agent: Gather information
├── Handoff to Analyst Agent
├── Analyst Agent: Deep analysis
├── Handoff to Writer Agent
├── Writer Agent: Generate report
└── Handoff to Reviewer Agent
```

--------------------------------

### Dockerfile for Praxis Agent

Source: https://docs.prxs.ai/py-sdk/advanced-topics

A Dockerfile to build a production-ready image for a Praxis agent. It installs system dependencies, Poetry, copies project files, installs Python dependencies, exposes necessary ports, and sets the default command to run the agent.

```dockerfile
FROM python:3.11-slim

WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y 
    gcc 
    git 
    && rm -rf /var/lib/apt/lists/*

# Install Poetry
RUN pip install poetry

# Copy project files
COPY pyproject.toml poetry.lock ./
COPY src/ ./src/

# Install dependencies
RUN poetry config virtualenvs.create false 
    && poetry install --no-dev --no-interaction --no-ansi

# Create workspace
RUN mkdir -p /workspace /data

# Expose ports
EXPOSE 8000 4001 9000 9090

# Run agent
CMD ["python", "-m", "praxis.agent.main", "--config", "/app/config/agent.yaml"]
```

--------------------------------

### Workflow Started Event

Source: https://docs.prxs.ai/py-sdk/api-reference

Indicates that a workflow has begun execution.

```json
{
  "type": "workflow.started",
  "data": {
    "workflow_id": "wf-abc123",
    "started_at": "2024-01-15T10:30:01Z"
  }
}
```

--------------------------------

### Backend Application Structure

Source: https://docs.prxs.ai/explorer/architecture

This outlines the directory structure for the Go backend application, highlighting key components like the application entry point, ERC-8004 implementation, explorer logic, and configuration files.

```tree
backend/
├── cmd/
│   └── praxis-explorer/
│       └── main.go              # Application entry point
├── internal/
│   ├── erc8004/                 # ERC-8004 standard implementation
│   │   ├── identity/            # Identity management
│   │   ├── reputation/          # Reputation tracking
│   │   ├── signature/           # Signature verification
│   │   └── validation/          # Contract validation
│   └── explorer/
│       ├── api/
│       │   └── handlers.go      # HTTP request handlers
│       ├── indexer/
│       │   ├── indexer.go       # Blockchain event indexer
│       │   └── config.go        # Indexer configuration
│       ├── store/
│       │   ├── postgres.go      # PostgreSQL implementation
│       │   └── models.go        # Data models
│       └── server.go            # HTTP server setup
├── configs/
│   └── erc8004.yaml            # Network configuration
└── migrations/                  # Database migrations
```

--------------------------------

### Get Network-Specific Statistics

Source: https://docs.prxs.ai/explorer/api-reference

Retrieves statistics for a particular blockchain network.

```APIDOC
## GET /api/stats/network/:network

### Description
Get network-specific statistics.

### Method
GET

### Endpoint
/api/stats/network/:network

### Parameters
#### Path Parameters
- **network** (string) - Required - Network name

### Request Example
```
GET /api/stats/network/sepolia HTTP/1.1
Host: localhost:8080
```

### Response
#### Success Response (200)
- **network** (string) - The name of the network.
- **stats** (object) - Network-specific statistics
  - **total_agents** (integer)
  - **average_reputation** (number)
  - **total_interactions** (integer)
  - **agents_by_domain** (object)
  - **registration_trend** (array of objects)

#### Response Example
```json
{
  "network": "sepolia",
  "stats": {
    "total_agents": 247,
    "average_reputation": 4.1,
    "total_interactions": 12456,
    "agents_by_domain": {
      "finance": 89,
      "healthcare": 45,
      "research": 67,
      "other": 46
    },
    "registration_trend": [
      {
        "date": "2024-01-08",
        "count": 12
      },
      {
        "date": "2024-01-09",
        "count": 15
      }
    ]
  }
}
```

### Status Codes
- `200 OK` - Success
- `404 Not Found` - Network not found
- `500 Internal Server Error` - Server error
```

--------------------------------

### Clone Praxis Go SDK Repository

Source: https://docs.prxs.ai/getting-started/go-sdk/quickstart

Clone the official Praxis Go SDK repository and navigate into the directory. This is the first step to setting up your local development environment.

```bash
git clone https://github.com/prxs-ai/praxis-go-sdk
cd praxis-go-sdk
```
Tokens:
Raw