> ## 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.

# Managed Typed Configs

> Type-safe networking and package configuration for managed agents

Typed configuration classes provide type safety and validation for networking and package management in managed environments.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Configuration Types"
        A[📝 Dict Config] --> B[🔄 Migration Path]
        B --> C[⚡ Typed Config]
        
        D[🌐 NetworkingConfig] --> E[🔒 Security Rules]
        F[📦 PackagesConfig] --> G[🛠️ Multi-Language Support]
    end
    
    classDef dict fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef typed fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef feature fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef result fill:#10B981,stroke:#7C90A0,color:#fff
    
    class A,B dict
    class C,D,F typed
    class E,G result
```

## Quick Start

<Steps>
  <Step title="NetworkingConfig Usage">
    Configure network access with type safety.

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai import ManagedConfig, NetworkingConfig, NetworkingType

    # Unrestricted networking (default)
    config = ManagedConfig(
        networking=NetworkingConfig(
            type=NetworkingType.UNRESTRICTED
        )
    )

    # Limited networking with allowed hosts
    config = ManagedConfig(
        networking=NetworkingConfig(
            type=NetworkingType.LIMITED,
            allowed_hosts=["api.openai.com", "github.com"],
            allow_mcp_servers=True,
            allow_package_managers=False
        )
    )
    ```
  </Step>

  <Step title="PackagesConfig Usage">
    Configure package dependencies for all supported managers.

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonai import ManagedConfig, PackagesConfig

    config = ManagedConfig(
        packages=PackagesConfig(
            pip=["pandas", "numpy", "matplotlib"],
            npm=["express", "lodash"],
            apt=["curl", "git", "vim"],
            cargo=["serde", "tokio"],
            gem=["rails", "sinatra"],
            go=["github.com/gin-gonic/gin"]
        )
    )

    # Convert to dict for API serialization
    packages_dict = config.packages.to_dict()
    # Result: {"pip": ["pandas", "numpy", "matplotlib"], "npm": ["express", "lodash"], ...}
    ```
  </Step>
</Steps>

***

## How It Works

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph TB
    subgraph "Configuration Flow"
        A[🔧 User Config] --> B{Config Type?}
        B -->|Dict| C[📝 Legacy Format]
        B -->|Typed| D[⚡ Typed Classes]
        
        C --> E[🔄 Runtime Validation]
        D --> F[🛡️ Compile-time Safety]
        
        E --> G[🌐 API Serialization]
        F --> G
    end
    
    classDef user fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef legacy fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef typed fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef validation fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef api fill:#10B981,stroke:#7C90A0,color:#fff
    
    class A user
    class B,C,E legacy
    class D,F typed
    class G api
```

***

## NetworkingConfig

### Configuration Options

| Option                   | Type                  | Default        | Description                          |
| ------------------------ | --------------------- | -------------- | ------------------------------------ |
| `type`                   | `NetworkingType`      | `UNRESTRICTED` | Network access level                 |
| `allowed_hosts`          | `Optional[List[str]]` | `None`         | Permitted hostnames for LIMITED type |
| `allow_mcp_servers`      | `bool`                | `True`         | Allow MCP server connections         |
| `allow_package_managers` | `bool`                | `True`         | Allow package manager access         |

### NetworkingType Enum

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

# Available types
NetworkingType.UNRESTRICTED  # Full internet access
NetworkingType.LIMITED       # Restricted to allowed_hosts
```

### Examples

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Unrestricted networking
net = NetworkingConfig(type=NetworkingType.UNRESTRICTED)

# Production-safe limited networking  
net = NetworkingConfig(
    type=NetworkingType.LIMITED,
    allowed_hosts=[
        "api.openai.com",
        "api.anthropic.com", 
        "github.com",
        "pypi.org"
    ],
    allow_mcp_servers=True,
    allow_package_managers=True
)

# Minimal networking (MCP and packages only)
net = NetworkingConfig(
    type=NetworkingType.LIMITED,
    allowed_hosts=[],
    allow_mcp_servers=True,
    allow_package_managers=True
)
```

***

## PackagesConfig

### Configuration Options

| Package Manager | Type                  | Default | Description                   |
| --------------- | --------------------- | ------- | ----------------------------- |
| `pip`           | `Optional[List[str]]` | `None`  | Python packages               |
| `npm`           | `Optional[List[str]]` | `None`  | Node.js packages              |
| `apt`           | `Optional[List[str]]` | `None`  | Debian/Ubuntu system packages |
| `cargo`         | `Optional[List[str]]` | `None`  | Rust packages                 |
| `gem`           | `Optional[List[str]]` | `None`  | Ruby packages                 |
| `go`            | `Optional[List[str]]` | `None`  | Go modules                    |

### Examples

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Data science environment
pkg = PackagesConfig(
    pip=["pandas", "numpy", "scikit-learn", "jupyter"],
    apt=["build-essential", "git"]
)

# Full-stack development
pkg = PackagesConfig(
    pip=["flask", "requests"],
    npm=["express", "react", "typescript"],
    apt=["curl", "git", "nginx"]
)

# Multi-language project
pkg = PackagesConfig(
    pip=["requests"],
    npm=["lodash"],
    cargo=["serde"],
    gem=["rails"],
    go=["github.com/gin-gonic/gin"],
    apt=["git", "build-essential"]
)

# Serialize for API
api_dict = pkg.to_dict()
```

***

## Common Patterns

### Migration from Dict Config

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Old dict-based config (still works)
config_old = ManagedConfig(
    networking={"type": "limited", "allowed_hosts": ["api.openai.com"]},
    packages={"pip": ["pandas"], "npm": ["express"]}
)

# New typed config (recommended)
config_new = ManagedConfig(
    networking=NetworkingConfig(
        type=NetworkingType.LIMITED,
        allowed_hosts=["api.openai.com"]
    ),
    packages=PackagesConfig(
        pip=["pandas"],
        npm=["express"]
    )
)
```

### Environment-Specific Configurations

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
def get_networking_config(env: str) -> NetworkingConfig:
    if env == "production":
        return NetworkingConfig(
            type=NetworkingType.LIMITED,
            allowed_hosts=["api.company.com"],
            allow_mcp_servers=False
        )
    elif env == "staging":
        return NetworkingConfig(
            type=NetworkingType.LIMITED,
            allowed_hosts=["api.company.com", "staging.api.com"],
            allow_mcp_servers=True
        )
    else:  # development
        return NetworkingConfig(type=NetworkingType.UNRESTRICTED)

# Use in config
config = ManagedConfig(
    networking=get_networking_config("production")
)
```

### Package Templates

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
class PackageTemplates:
    @staticmethod
    def data_science() -> PackagesConfig:
        return PackagesConfig(
            pip=["pandas", "numpy", "matplotlib", "seaborn", "jupyter"],
            apt=["build-essential"]
        )
    
    @staticmethod
    def web_development() -> PackagesConfig:
        return PackagesConfig(
            npm=["express", "react", "typescript"],
            pip=["flask", "requests"],
            apt=["nginx", "curl"]
        )
    
    @staticmethod
    def machine_learning() -> PackagesConfig:
        return PackagesConfig(
            pip=["torch", "transformers", "scikit-learn", "datasets"],
            apt=["build-essential", "git-lfs"]
        )

# Use templates
config = ManagedConfig(
    packages=PackageTemplates.data_science()
)
```

***

## Best Practices

<AccordionGroup>
  <Accordion title="Security Configuration">
    Use LIMITED networking in production environments:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # Production: Restrictive networking
    prod_net = NetworkingConfig(
        type=NetworkingType.LIMITED,
        allowed_hosts=["essential-api.com"],
        allow_mcp_servers=False,  # Disable if not needed
        allow_package_managers=True  # Keep for dependency installation
    )
    ```
  </Accordion>

  <Accordion title="Package Management">
    Organize packages logically and minimize dependencies:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # Good: Minimal, specific packages
    pkg = PackagesConfig(
        pip=["requests", "pydantic"],  # Only what's needed
        apt=["git"]  # Essential tools only
    )

    # Avoid: Large, unfocused package lists
    # pkg = PackagesConfig(pip=["pandas", "torch", "flask", ...])  # Too broad
    ```
  </Accordion>

  <Accordion title="Backward Compatibility">
    Both dict and typed configs work seamlessly:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # Legacy dict format still supported
    config = ManagedConfig(
        networking={"type": "unrestricted"},
        packages={"pip": ["pandas"]}
    )

    # Typed format provides better IDE support and validation
    config = ManagedConfig(
        networking=NetworkingConfig(type=NetworkingType.UNRESTRICTED),
        packages=PackagesConfig(pip=["pandas"])
    )
    ```
  </Accordion>

  <Accordion title="Type Safety Benefits">
    * **IDE Support**: Auto-completion and type checking
    * **Runtime Validation**: Early error detection
    * **API Compatibility**: Seamless serialization with `to_dict()`
    * **Documentation**: Self-documenting configuration structure
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup cols={2}>
  <Card title="Managed Vault" icon="key" href="/docs/features/managed-vault">
    OAuth credentials management for managed agents
  </Card>

  <Card title="Sandboxed Agent" icon="sandbox" href="/docs/features/sandboxed-agent">
    Local agent loop with configurable tool sandboxing
  </Card>
</CardGroup>