> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praison.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# ToolRegistry AutoGen Migration

> Migrate from ToolRegistry AutoGen methods to AutoGenAdapter for cleaner architecture

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonai.agents_generator import AgentsGenerator
from praisonai.framework_adapters import AutoGenAdapter
from praisonai.tool_registry import ToolRegistry

# Create AutoGen tools using the adapter
adapter = AutoGenAdapter()
agent_gen = AgentsGenerator("agents.yaml", "autogen", config_list=[{"model": "gpt-4o"}])
result = agent_gen.generate_crew_and_kickoff()
print(result)
```

ToolRegistry AutoGen methods remain available for backward compatibility, but new code should use the AutoGenAdapter class for cleaner separation of concerns.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Migration Path"
        A[🔧 ToolRegistry AutoGen methods] --> B[✅ Still Available]
        C[📦 AutoGenAdapter] --> D[🎯 Recommended for new code]
        B --> E[🔄 Gradual migration]
        E --> D
    end
    
    classDef legacy fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef new fill:#10B981,stroke:#7C90A0,color:#fff
    classDef available fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef migration fill:#6366F1,stroke:#7C90A0,color:#fff
    
    class A legacy
    class B available
    class C,D new
    class E migration
```

## Quick Start

Migrate from ToolRegistry AutoGen methods to AutoGenAdapter for better architecture separation.

<Steps>
  <Step title="Legacy (still works)">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.tool_registry import ToolRegistry

    def search_tool(query: str) -> str:
        return f"Found results for: {query}"

    registry = ToolRegistry()
    registry.register_autogen_adapter("search", search_tool)
    adapter = registry.get_autogen_adapter("search")
    builtin_tools = registry.list_autogen_adapters()
    registry.register_builtin_autogen_adapters()
    ```
  </Step>

  <Step title="Recommended (new code)">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.framework_adapters import AutoGenAdapter
    from praisonai.tool_registry import ToolRegistry

    def search_tool(query: str) -> str:
        return f"Found results for: {query}"

    # Use AutoGenAdapter for AutoGen-specific features
    adapter = AutoGenAdapter()

    # Use ToolRegistry for general tool registration
    registry = ToolRegistry()
    registry.register_function("search", search_tool)
    ```
  </Step>
</Steps>

***

## How It Works

The migration involves moving from ToolRegistry AutoGen methods to the dedicated AutoGenAdapter class.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant User
    participant ToolRegistry
    participant AutoGenAdapter
    participant AutoGen
    
    User->>ToolRegistry: register_autogen_adapter()
    ToolRegistry->>AutoGen: Configure AutoGen tools
    AutoGen-->>User: Tool registered
    
    Note over User,AutoGen: Legacy path still works
    
    User->>AutoGenAdapter: Use AutoGenAdapter
    AutoGenAdapter->>AutoGen: Direct integration
    AutoGen-->>User: Tool registered
    
    Note over User,AutoGen: Recommended path for new code
    
    classDef legacy fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef new fill:#10B981,stroke:#7C90A0,color:#fff
    
    class ToolRegistry legacy
    class AutoGenAdapter new
```

## Configuration Options

Both approaches support the same configuration patterns for AutoGen tool integration.

| Option              | Type           | Default  | Description                         |
| ------------------- | -------------- | -------- | ----------------------------------- |
| `tool_name`         | `str`          | Required | Name identifier for the tool        |
| `adapter_function`  | `Callable`     | Required | Tool implementation function        |
| `registry_instance` | `ToolRegistry` | `None`   | Optional registry instance          |
| `builtin_adapters`  | `bool`         | `False`  | Whether to include builtin adapters |

## What Changed

| Method                                              | Status        | Replacement                                              |
| --------------------------------------------------- | ------------- | -------------------------------------------------------- |
| `register_autogen_adapter(tool_type_name, adapter)` | **Available** | Use `AutoGenAdapter` from `praisonai.framework_adapters` |
| `get_autogen_adapter(tool_type_name)`               | **Available** | Use `AutoGenAdapter` from `praisonai.framework_adapters` |
| `list_autogen_adapters()`                           | **Available** | Use `AutoGenAdapter` from `praisonai.framework_adapters` |
| `register_builtin_autogen_adapters()`               | **Available** | Use `AutoGenAdapter` from `praisonai.framework_adapters` |

***

## Common Patterns

### Tool Registration

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Legacy approach (still works)
from praisonai.tool_registry import ToolRegistry

def search_tool(query: str) -> str:
    return f"Searched for: {query}"

registry = ToolRegistry()
registry.register_autogen_adapter("search", search_tool)

# Recommended approach
from praisonai.framework_adapters import AutoGenAdapter

def search_tool(query: str) -> str:
    return f"Searched for: {query}"

adapter = AutoGenAdapter()
```

### Listing Available Tools

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Legacy approach
from praisonai.tool_registry import ToolRegistry

registry = ToolRegistry()
autogen_tools = registry.list_autogen_adapters()
print(f"Available tools: {autogen_tools}")

# Recommended approach
from praisonai.framework_adapters import AutoGenAdapter

adapter = AutoGenAdapter()
# Use adapter's methods for AutoGen-specific functionality
```

### Builtin Registration

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Legacy approach
from praisonai.tool_registry import ToolRegistry

registry = ToolRegistry()
registry.register_builtin_autogen_adapters()
print("Builtin adapters registered")

# Recommended approach
from praisonai.framework_adapters import AutoGenAdapter

adapter = AutoGenAdapter()
# AutoGen integration handled by adapter
print("AutoGen adapter ready")
```

***

## Best Practices

<AccordionGroup>
  <Accordion title="Keep legacy code working">
    Existing ToolRegistry AutoGen code continues to work without changes:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.tool_registry import ToolRegistry

    def web_search(query: str) -> str:
        return f"Search results for: {query}"

    # This continues to work
    registry = ToolRegistry()
    registry.register_autogen_adapter("web_search", web_search)
    print("AutoGen adapter registered successfully")
    ```
  </Accordion>

  <Accordion title="Use AutoGenAdapter for new projects">
    For new code, prefer the AutoGenAdapter class for better separation:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.framework_adapters import AutoGenAdapter
    from praisonai.tool_registry import ToolRegistry

    def web_search(query: str) -> str:
        return f"Search results for: {query}"

    # Recommended approach
    adapter = AutoGenAdapter()
    registry = ToolRegistry()
    registry.register_function("web_search", web_search)
    print("Tools registered using recommended pattern")
    ```
  </Accordion>

  <Accordion title="Migrate incrementally">
    Gradually move from ToolRegistry AutoGen methods to AutoGenAdapter:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.tool_registry import ToolRegistry
    from praisonai.framework_adapters import AutoGenAdapter

    def search_tool(query: str) -> str:
        return f"Found: {query}"

    def analyze_tool(data: str) -> str:
        return f"Analyzed: {data}"

    # Step 1: Keep existing registrations
    registry = ToolRegistry()
    registry.register_autogen_adapter("search", search_tool)

    # Step 2: Add new tools using recommended pattern
    adapter = AutoGenAdapter()
    registry.register_function("analyze", analyze_tool)

    # Step 3: Gradually convert when ready
    ```
  </Accordion>

  <Accordion title="Test both approaches">
    Ensure compatibility by testing both legacy and recommended patterns:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai.tool_registry import ToolRegistry
    from praisonai.framework_adapters import AutoGenAdapter

    def test_tool(input: str) -> str:
        return f"Processed: {input}"

    # Test legacy approach
    registry = ToolRegistry()
    registry.register_autogen_adapter("test", test_tool)
    legacy_result = registry.get_autogen_adapter("test")

    # Test recommended approach  
    adapter = AutoGenAdapter()
    registry.register_function("test", test_tool)
    recommended_result = registry.get_function("test")

    print(f"Both approaches work: {legacy_result is not None and recommended_result is not None}")
    ```
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup cols={2}>
  <Card title="Framework Availability" icon="check-circle" href="/docs/features/framework-availability">
    Framework detection and availability checking
  </Card>

  <Card title="Thread Safety" icon="lock" href="/docs/features/thread-safety">
    Thread-safe tool registry operations
  </Card>
</CardGroup>