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

# Extending the Platform

> Custom nodes, integrations, and plugins

Noxus is designed to be highly extensible. The platform can be extended using **Plugins**, which allow you to build custom functionality, specialized nodes, and proprietary integrations tailored to your specific requirements.

## Examples

Here are some examples of how you can extend the platform using different plugin types:

<Tabs>
  <Tab title="Custom Nodes">
    **Create Specialized Nodes**

    Build custom nodes for domain-specific operations:

    * Proprietary API integrations
    * Specialized data transformations
    * Industry-specific AI operations
    * Custom business logic

    ```python theme={null}
    from noxus_plugins import Node, Input, Output

    class CustomTransform(Node):
        name = "My Custom Transform"
        category = "Data Processing"
        
        inputs = [
            Input("data", type="string", required=True),
            Input("config", type="object")
        ]
        
        outputs = [
            Output("result", type="string")
        ]
        
        def execute(self, inputs):
            # Your custom logic
            result = self.process(inputs['data'])
            return {"result": result}
    ```
  </Tab>

  <Tab title="Integrations">
    **Connect Proprietary Systems**

    Build integrations for internal or specialized systems:

    * Internal databases and APIs
    * Legacy system connectors
    * Proprietary SaaS tools
    * Custom authentication schemes

    ```python theme={null}
    from noxus_plugins import Integration

    class InternalCRM(Integration):
        name = "Internal CRM"
        auth_type = "oauth2"
        
        def get_customer(self, customer_id):
            # Integration logic
            return self.api_call(f"/customers/{customer_id}")
    ```
  </Tab>

  <Tab title="AI Models">
    **Custom Model Providers**

    Integrate proprietary or fine-tuned models:

    * Self-hosted models
    * Fine-tuned private models
    * Custom inference endpoints
    * On-premises model servers

    ```python theme={null}
    from noxus_plugins import ModelProvider

    class CustomModelProvider(ModelProvider):
        name = "Internal Models"
        
        def generate(self, prompt, model, **kwargs):
            # Call your model endpoint
            return self.inference_api.generate(prompt)
    ```
  </Tab>
</Tabs>

While the entire Noxus ecosystem is built on a robust, language-agnostic API, we provide a comprehensive toolkit in **Python** and a dedicated **CLI** to streamline the development, testing, and deployment of your extensions.

## Language-Agnostic Development

Because Noxus is built on a standardized HTTP/REST architecture, you are not limited to Python for plugin development. Any language capable of hosting an HTTP server (such as Go, Node.js, or Rust) can be used to build a Noxus-compatible plugin.

### HTTP Specification

The platform communicates with plugins via a well-defined HTTP interface. By implementing the required endpoints for node discovery and execution, you can integrate your own custom services directly into the Noxus workflow engine.

<Note>
  We are currently finalizing the official **Plugin HTTP Specification** documentation. This will include detailed OpenAPI schemas and contract requirements for developers building plugins in non-Python languages. More information will be available soon.
</Note>

***

<Card title="Plugin Development Guide" icon="puzzle-piece" href="/developers/plugins/overview">
  Check the full guide to learn how to build and deploy custom plugins
</Card>