updated custom domain

Author: getfounded

.github/workflows/deploy-docs.yml

@@ -4,8 +4,6 @@ on:
   push:
     branches:
       - main
-    paths:
-      - 'website/**'
   workflow_dispatch:
 
 permissions:

README.md

@@ -42,14 +42,6 @@ Bizy consists of several key components:
 - **FastMCP**: High-performance MCP implementations and tool coordination
 - **Zep AI**: Memory systems and temporal knowledge graphs
 
-This project is organized into sprints focusing on ecosystem contribution:
-
-- **Sprint 1**: Cross-Framework Foundation (Days 1-10)
-- **Sprint 2**: Advanced Multi-Framework Patterns (Days 11-20)
-- **Sprint 3**: Ecosystem Leadership Establishment (Days 21-30)
-
-See `CLAUDE.md` for detailed implementation tasks.
-
 ## Contributing
 
 We welcome contributions that enhance cross-framework business logic coordination. Please see our contribution guidelines in `/docs/community/contributing.md`.

website/README.md

@@ -0,0 +1,23 @@
+# Bizy Documentation Website
+
+This directory contains the Docusaurus-based documentation for Bizy.
+
+## Local Development
+
+```bash
+cd website
+npm install
+npm start
+```
+
+## Build
+
+```bash
+npm run build
+```
+
+The build artifacts will be stored in the `build/` directory.
+
+## Deployment
+
+The site is automatically deployed to GitHub Pages when changes are pushed to the main branch.

website/docs/getting-started/first-workflow.md

@@ -0,0 +1,169 @@
+---
+sidebar_position: 3
+---
+
+# Your First Workflow
+
+Build a complete customer service workflow using multiple AI frameworks.
+
+## Overview
+
+We'll create a workflow that:
+1. Analyzes customer sentiment (LangChain)
+2. Checks customer history (Zep Memory)
+3. Creates support ticket (MCP Tools)
+4. Starts resolution workflow (Temporal)
+
+## Step 1: Define the Business Rules
+
+Create `rules/customer_service.yaml`:
+
+```yaml
+rule_set: customer_service
+rules:
+  - rule: analyze_sentiment
+    description: Analyze customer message sentiment
+    priority: high
+    conditions:
+      - message.text != null
+    actions:
+      - framework: langchain
+        action: sentiment_analysis
+        output: sentiment_score
+
+  - rule: check_escalation
+    description: Determine if escalation needed
+    priority: high
+    conditions:
+      - sentiment_score < 0.3
+      - customer.tier == "premium"
+    actions:
+      - framework: zep
+        action: get_customer_history
+      - framework: temporal
+        action: start_escalation_workflow
+        params:
+          priority: high
+
+  - rule: create_ticket
+    description: Create support ticket
+    priority: medium
+    conditions:
+      - sentiment_score < 0.7
+    actions:
+      - framework: mcp
+        action: create_ticket
+        params:
+          type: support
+          auto_assign: true
+```
+
+## Step 2: Initialize the Frameworks
+
+```python
+from bizy.core import MetaOrchestrator
+from bizy.adapters import (
+    LangChainAdapter,
+    TemporalAdapter,
+    MCPAdapter,
+    ZepAdapter
+)
+
+async def setup_orchestrator():
+    orchestrator = MetaOrchestrator()
+    
+    # Configure adapters
+    adapters = {
+        "langchain": LangChainAdapter({"api_key": "..."}),
+        "temporal": TemporalAdapter({"host": "localhost"}),
+        "mcp": MCPAdapter({"server_url": "http://localhost:8080"}),
+        "zep": ZepAdapter({"api_url": "http://localhost:8000"})
+    }
+    
+    # Register all adapters
+    for name, adapter in adapters.items():
+        await adapter.connect()
+        orchestrator.register_adapter(name, adapter)
+    
+    # Load rules
+    orchestrator.load_rules("rules/customer_service.yaml")
+    
+    return orchestrator
+```
+
+## Step 3: Create the Workflow Handler
+
+```python
+class CustomerServiceHandler:
+    def __init__(self, orchestrator):
+        self.orchestrator = orchestrator
+    
+    async def handle_customer_message(self, customer_id: str, message: str):
+        # Prepare context
+        context = {
+            "customer": await self.get_customer_info(customer_id),
+            "message": {"text": message}
+        }
+        
+        # Execute rules
+        result = await self.orchestrator.execute(
+            rule_set="customer_service",
+            context=context
+        )
+        
+        return {
+            "ticket_id": result.get("ticket_id"),
+            "workflow_id": result.get("workflow_id"),
+            "sentiment": result.get("sentiment_score"),
+            "actions_taken": result.get("executed_actions")
+        }
+```
+
+## Step 4: Run the Workflow
+
+```python
+async def main():
+    # Setup
+    orchestrator = await setup_orchestrator()
+    handler = CustomerServiceHandler(orchestrator)
+    
+    # Handle a customer message
+    result = await handler.handle_customer_message(
+        customer_id="cust_123",
+        message="I'm very frustrated with the service!"
+    )
+    
+    print(f"Ticket created: {result['ticket_id']}")
+    print(f"Sentiment score: {result['sentiment']}")
+    print(f"Actions taken: {result['actions_taken']}")
+
+# Run
+import asyncio
+asyncio.run(main())
+```
+
+## Expected Output
+
+```
+Ticket created: TICK-2024-001
+Sentiment score: 0.2
+Actions taken: [
+    "langchain.sentiment_analysis",
+    "zep.get_customer_history", 
+    "temporal.start_escalation_workflow",
+    "mcp.create_ticket"
+]
+```
+
+## Next Steps
+
+- Add error handling and retries
+- Implement custom actions
+- Create workflow monitoring
+- Scale with multiple workers
+
+## Learn More
+
+- [Business Rule Patterns](../rules/best-practices)
+- [Error Handling](../tutorials/error-handling)
+- [Production Deployment](../deployment/requirements)

website/docs/getting-started/installation.md

@@ -0,0 +1,71 @@
+---
+sidebar_position: 1
+---
+
+# Installation
+
+Get Bizy up and running in your environment.
+
+## Prerequisites
+
+- Python 3.12 or higher
+- Poetry (for dependency management)
+- Redis (for event bus)
+- Git
+
+## Install with Poetry
+
+```bash
+# Clone the repository
+git clone https://github.com/getfounded/bizy.git
+cd bizy
+
+# Install dependencies
+poetry install
+
+# Activate virtual environment
+poetry shell
+```
+
+## Install with pip
+
+```bash
+pip install bizy
+```
+
+## Verify Installation
+
+```python
+import bizy
+print(bizy.__version__)
+# Output: 0.1.0
+```
+
+## Configure Environment
+
+Copy the example environment file:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with your configuration:
+
+```env
+# LangChain Configuration
+LANGCHAIN_API_KEY=your-api-key
+LANGCHAIN_MODEL=gpt-4
+
+# Temporal Configuration
+TEMPORAL_HOST=localhost
+TEMPORAL_PORT=7233
+
+# Redis Configuration
+REDIS_HOST=localhost
+REDIS_PORT=6379
+```
+
+## Next Steps
+
+- Follow the [Quick Start](./quick-start) guide
+- Create your [First Workflow](./first-workflow)

website/docs/getting-started/quick-start.md

@@ -0,0 +1,99 @@
+---
+sidebar_position: 2
+---
+
+# Quick Start
+
+Build your first cross-framework workflow in 5 minutes.
+
+## Basic Example
+
+### 1. Define a Business Rule
+
+Create a YAML file `rules/hello_world.yaml`:
+
+```yaml
+rule: hello_world
+description: Simple greeting rule
+priority: high
+conditions:
+  - input.name != null
+actions:
+  - framework: langchain
+    action: generate_greeting
+    params:
+      template: "Hello, {name}!"
+```
+
+### 2. Create the Orchestrator
+
+```python
+from bizy.core import MetaOrchestrator
+from bizy.adapters import LangChainAdapter
+
+# Initialize orchestrator
+orchestrator = MetaOrchestrator()
+
+# Register LangChain adapter
+langchain = LangChainAdapter({
+    "api_key": "your-api-key"
+})
+orchestrator.register_adapter("langchain", langchain)
+
+# Load business rules
+orchestrator.load_rules("rules/hello_world.yaml")
+```
+
+### 3. Execute the Rule
+
+```python
+# Execute business rule
+result = await orchestrator.execute(
+    rule_name="hello_world",
+    context={"name": "Alice"}
+)
+
+print(result)
+# Output: {"greeting": "Hello, Alice!"}
+```
+
+## Multi-Framework Example
+
+Coordinate between LangChain and Temporal:
+
+```python
+from bizy.adapters import TemporalAdapter
+
+# Add Temporal adapter
+temporal = TemporalAdapter({
+    "host": "localhost",
+    "port": 7233
+})
+orchestrator.register_adapter("temporal", temporal)
+
+# Define multi-framework rule
+rule = """
+rule: process_document
+conditions:
+  - document.type == "invoice"
+actions:
+  - framework: langchain
+    action: extract_data
+  - framework: temporal
+    action: start_approval_workflow
+    params:
+      workflow: "invoice_approval"
+"""
+
+# Execute
+result = await orchestrator.execute(
+    rule_name="process_document",
+    context={"document": {"type": "invoice", "content": "..."}}
+)
+```
+
+## What's Next?
+
+- Learn about [Business Rules](../rules/rule-syntax)
+- Explore [Framework Adapters](../adapters/langchain)
+- Build complex [Multi-Framework Scenarios](../tutorials/multi-framework-scenarios)

website/static/CNAME

@@ -0,0 +1 @@
+docs.bizy.work