Developer Quick Start

For background services, CLI tools, or custom backend orchestrators.

1. Dependencies

For a headless environment, you only need the core framework and an AI provider adapter.

<dependencies>
    <dependency>
        <groupId>uno.anahata</groupId>
        <artifactId>anahata-asi-core</artifactId>
        <version>1.0.0</version>
    </dependency>
    <dependency>
        <groupId>uno.anahata</groupId>
        <artifactId>anahata-asi-gemini</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

2. Configuration (DNA)

The AgiConfig defines the default AI provider, model, and which toolkits are enabled for the session.

import uno.anahata.asi.agi.AgiConfig;
import uno.anahata.asi.AbstractAsiContainer;

public class MyAppAgiConfig extends AgiConfig {
    public MyAppAgiConfig(AbstractAsiContainer container) {
        super(container);
        setSelectedProviderUuid("Gemini");
        setSelectedModelId("models/gemini-3.5-flash");
        
        // Register your custom toolkit!
        getToolClasses().add(EnterpriseToolkit.class);
    }
}

3. Container & Main

The AbstractAsiContainer acts as the host application, managing session lifecycles.

import uno.anahata.asi.AbstractAsiContainer;
import uno.anahata.asi.agi.Agi;
import uno.anahata.asi.agi.AgiConfig;

public class MyAppAsiContainer extends AbstractAsiContainer {
    public MyAppAsiContainer() {
        super("my-headless-app");
    }

    @Override
    public AgiConfig createNewAgiConfig() {
        return new MyAppAgiConfig(this);
    }

    @Override protected void onAgiOpened(Agi agi) {}
    @Override protected void onAgiClosed(Agi agi) {}
    @Override public Object getUI(Agi agi) { return null; }
}

import uno.anahata.asi.agi.Agi;
import uno.anahata.asi.gemini.GeminiAiProvider;
import uno.anahata.asi.agi.message.InputUserMessage;

public class Main {
    public static void main(String[] args) {
        MyAppAsiContainer container = new MyAppAsiContainer();
        container.registerProvider(new GeminiAiProvider());
        // API key is loaded from ~/.anahata/asi/my-headless-app/Gemini/api_keys.txt
        
        Agi agi = container.createNewAgi();
        
        // Inject the custom context provider
        agi.getContextManager().registerContextProvider(new DatabaseContextProvider());
        
        InputUserMessage msg = new InputUserMessage(agi);
        msg.setText("What is the current database status? Also, calculate the projected revenue for EMEA.");
        agi.sendMessage(msg);
    }
}

Embed the ASI Chat UI and Tool Viewers into an existing Swing Application.

Dependencies

    <dependency>
        <groupId>uno.anahata</groupId>
        <artifactId>anahata-asi-swing</artifactId>
        <version>1.0.0</version>
    </dependency>

Embedded Configuration & Toolkits

Define your session DNA and register any custom toolkits you want to expose to the AI.

import uno.anahata.asi.swing.agi.SwingAgiConfig;
import uno.anahata.asi.AbstractAsiContainer;

public class EmbeddedSwingAppAgiConfig extends SwingAgiConfig {
    public EmbeddedSwingAppAgiConfig(AbstractAsiContainer container) {
        super(container);
        // Register a custom toolkit specific to your embedded app
        getToolClasses().add(MyCustomBusinessToolkit.class);
    }
}

Container & Dashboard (Cards View)

While AsiDesktopAsiContainer auto-manages tabs, embedding via AbstractSwingAsiContainer directly gives you absolute control over where the AI chat appears (e.g., floating windows, internal frames, or custom tab managers). You provide this integration logic via getUI, focusUI, and closeUI.

To display the session dashboard (like the sticky-note cards), simply instantiate an AsiCardsContainerPanel.

import uno.anahata.asi.swing.AbstractSwingAsiContainer;
import uno.anahata.asi.swing.AsiCardsContainerPanel;
import uno.anahata.asi.swing.agi.AgiPanel;
import uno.anahata.asi.agi.Agi;
import uno.anahata.asi.agi.AgiConfig;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.swing.JTabbedPane;

public class EmbeddedSwingAppAsiContainer extends AbstractSwingAsiContainer {
    private final JTabbedPane appTabs; // Your app's existing tab manager
    // Cache to ensure we only create one UI panel per session!
    private final Map<String, AgiPanel> activePanels = new ConcurrentHashMap<>();

    public EmbeddedSwingAppAsiContainer(JTabbedPane appTabs) {
        super("my-embedded-app");
        this.appTabs = appTabs;
        
        // Render the out-of-the-box Cards Dashboard
        AsiCardsContainerPanel dashboard = new AsiCardsContainerPanel(this);
        appTabs.addTab("AI Sessions", dashboard);
    }

    @Override
    public AgiConfig createNewAgiConfig() {
        return new EmbeddedSwingAppAgiConfig(this);
    }

    // --- The orchestration contract ---
    // You define exactly how your app displays an individual AI session!

    @Override
    public AgiPanel getUI(Agi agi) {
        // CRITICAL: Always cache and return the same panel instance for a given session
        return activePanels.computeIfAbsent(agi.getConfig().getSessionId(), id -> {
            AgiPanel panel = new AgiPanel(agi);
            panel.initComponents();
            
            // Customization: Remove the Support and CwGC tabs for a cleaner embedded look
            panel.getTabbedPane().remove(panel.getSupportPanel());
            panel.getTabbedPane().remove(panel.getCwGcPanel());
            
            return panel;
        });
    }
    
    @Override 
    protected void focusUI(Agi agi) {
        // E.g., open a new tab in your app for this specific session
        AgiPanel panel = getAgiPanel(agi);
        if (appTabs.indexOfComponent(panel) == -1) {
            appTabs.addTab(agi.getNickname(), panel);
        }
        appTabs.setSelectedComponent(panel);
    }
    
    @Override 
    protected void closeUI(Agi agi) { 
        AgiPanel panel = activePanels.remove(agi.getConfig().getSessionId());
        if (panel != null) {
            appTabs.remove(panel);
        }
    }
}

Build a customized standalone AI Desktop app using the ASI Desktop framework.

1. Dependencies

    <dependency>
        <groupId>uno.anahata</groupId>
        <artifactId>anahata-asi-desktop</artifactId>
        <version>1.0.0</version>
    </dependency>

2. Container & Config

Extend AsiDesktopAsiContainer and define your custom default providers and configuration.

import uno.anahata.asi.destkop.swing.AsiDesktopAsiContainer;
import uno.anahata.asi.agi.AgiConfig;

public class MyAsiContainer extends AsiDesktopAsiContainer {
    public MyAsiContainer() {
        super("MyCustomApp");
        // Register custom providers here if needed
    }

    @Override
    public AgiConfig createNewAgiConfig() {
        return new MyAgiConfig(this);
    }
}

3. Main Panel (Dashboard)

Extend AsiDesktopMainPanel to inject your own application-specific tabs alongside the AI container.

import uno.anahata.asi.destkop.swing.AsiDesktopMainPanel;

public class MyMainPanel extends AsiDesktopMainPanel {
    public MyMainPanel(MyAsiContainer container) {
        super(container);
        // Add custom application tabs next to the ASI dashboard
        tabbedPane.addTab("📈 Custom Dashboard", new MyCustomPanel());
        
        // Prevent closing the custom dashboard
        tabbedPane.putClientProperty("JTabbedPane.tabCloseCondition", 
            (java.util.function.Predicate<Integer>) tabIndex -> tabIndex > 0);
    }
}

4. Application Launcher

Bootstrap the FlatLaf theme and display your custom JFrame.

import com.formdev.flatlaf.FlatLightLaf;
import javax.swing.*;
import java.awt.BorderLayout;

public class Main {
    public static void main(String[] args) {
        try { UIManager.setLookAndFeel(new FlatLightLaf()); } catch (Exception e) {}
        
        MyAsiContainer container = new MyAsiContainer();
        
        SwingUtilities.invokeLater(() -> {
            JFrame frame = new JFrame("My ASI Desktop App");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            
            MyMainPanel mainPanel = new MyMainPanel(container);
            frame.add(mainPanel, BorderLayout.CENTER);
            
            frame.setSize(1400, 900);
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
            
            mainPanel.start();
        });
    }
}

Create a NetBeans module that extends Anahata ASI Studio with custom toolkits.

Dependencies

Declare the Anahata Studio API dependency in your suite or standalone NBM module POM:

<dependency>
    <groupId>uno.anahata</groupId>
    <artifactId>anahata-asi-nb</artifactId>
    <version>1.0.0</version>
    <type>nbm</type>
</dependency>

Module Installer

import org.openide.modules.ModuleInstall;
import uno.anahata.asi.nb.AnahataInstaller;

public class MyModuleInstaller extends ModuleInstall {
    @Override
    public void restored() {
        // Register your custom toolkit into the global ASI environment templates
        AnahataInstaller.getContainer().getPreferences()
            .getAgiTemplate().getToolClasses().add(MyCustomToolkit.class);
    }
}