Quick Start Guide

This guide will help you get started with JuliaOS by walking you through the process of creating and running a simple agent and swarm.

Starting the JuliaOS Server

Before you can use JuliaOS, you need to start the Julia backend server:

cd /path/to/JuliaOS
julia julia/julia_server.jl

This will start the JuliaOS server on port 8052 by default.

Using the CLI

JuliaOS provides an interactive CLI for managing agents and swarms:

cd /path/to/JuliaOS
node packages/cli/interactive.cjs

This will start the interactive CLI, which provides a menu-based interface for creating and managing agents, swarms, wallets, and more.

Using the Julia API

Creating an Agent

using JuliaOS.Agents

# Create a trading agent
agent = Agents.create_agent(
    "TradingAgent",
    "trading",
    Dict("risk_tolerance" => "medium", "max_position_size" => 1000)
)

# Start the agent
Agents.start_agent(agent["id"])

# Execute a task with the agent
task_result = Agents.execute_task(
    agent["id"],
    Dict(
        "action" => "analyze_market",
        "market" => "crypto",
        "timeframe" => "1d"
    )
)

println("Task result: ", task_result)

Creating a Swarm

using JuliaOS.Swarms

# Create a swarm
swarm = Swarms.create_swarm(
    "OptimizationSwarm",
    "DE",
    Dict("population_size" => 50, "crossover_rate" => 0.8, "mutation_factor" => 0.5)
)

# Run optimization
result = Swarms.run_optimization(
    swarm["id"],
    "function(x) return sum(x.^2) end",
    [],  # constraints
    Dict("bounds" => [(-10, 10), (-10, 10), (-10, 10)], "max_iterations" => 100)
)

println("Optimization result: ", result)

Using the TypeScript Framework

Creating an Agent

import { JuliaBridge } from '@juliaos/julia-bridge';
import { Agents } from '@juliaos/framework';

// Initialize the bridge
const bridge = new JuliaBridge({ host: 'localhost', port: 8052 });
await bridge.initialize();

// Create framework modules
const agents = new Agents(bridge);

// Create an agent
const agent = await agents.createAgent({
  name: 'TradingAgent',
  type: 'trading',
  config: { risk_tolerance: 'medium', max_position_size: 1000 }
});

// Start the agent
await agents.startAgent(agent.id);

// Execute a task with the agent
const taskResult = await agents.executeTask(agent.id, {
  action: 'analyze_market',
  market: 'crypto',
  timeframe: '1d'
});

console.log('Task result:', taskResult);

Creating a Swarm

import { JuliaBridge } from '@juliaos/julia-bridge';
import { Swarms } from '@juliaos/framework';

// Initialize the bridge
const bridge = new JuliaBridge({ host: 'localhost', port: 8052 });
await bridge.initialize();

// Create framework modules
const swarms = new Swarms(bridge);

// Create a swarm
const swarm = await swarms.createSwarm({
  name: 'OptimizationSwarm',
  algorithm: 'DE',
  config: {
    population_size: 50,
    crossover_rate: 0.8,
    mutation_factor: 0.5
  }
});

// Run optimization
const result = await swarms.runOptimization(
  swarm.id,
  'function(x) return sum(x.^2) end',
  [],  // constraints
  {
    bounds: [[-10, 10], [-10, 10], [-10, 10]],
    max_iterations: 100
  }
);

console.log('Optimization result:', result);

Using the Python Wrapper

Creating an Agent

import asyncio
from juliaos import JuliaOS
from juliaos.agents import AgentType

async def main():
    # Initialize JuliaOS
    juliaos_client = JuliaOS(host="localhost", port=8052)
    await juliaos_client.connect()

    # Create an agent
    agent = await juliaos_client.agents.create_agent(
        name="TradingAgent",
        agent_type=AgentType.TRADING,
        config={
            "parameters": {
                "risk_tolerance": 0.5,
                "max_position_size": 1000.0,
                "take_profit": 0.05,
                "stop_loss": 0.03
            }
        }
    )

    # Start the agent
    await agent.start()

    # Execute a task with the agent
    task_result = await agent.execute_task({
        "action": "analyze_market",
        "market": "crypto",
        "timeframe": "1d"
    })

    print("Task result:", task_result)

    # Disconnect from JuliaOS
    await juliaos_client.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

Creating a Swarm

import asyncio
from juliaos import JuliaOS
from juliaos.swarms import SwarmType

async def main():
    # Initialize JuliaOS
    juliaos_client = JuliaOS(host="localhost", port=8052)
    await juliaos_client.connect()

    # Create a swarm
    swarm = await juliaos_client.swarms.create_swarm(
        name="OptimizationSwarm",
        swarm_type=SwarmType.OPTIMIZATION,
        algorithm="DE",
        dimensions=3,
        bounds=[(-10.0, 10.0)] * 3,
        config={
            "population_size": 50,
            "max_generations": 100,
            "crossover_probability": 0.8,
            "differential_weight": 0.5
        }
    )

    # Register an objective function
    function_id = "sphere"
    await juliaos_client.swarms.set_objective_function(
        function_id=function_id,
        function_code="function(x) return sum(x.^2) end",
        function_type="julia"
    )

    # Run optimization
    optimization_result = await swarm.run_optimization(
        function_id=function_id,
        max_iterations=100,
        max_time_seconds=60,
        tolerance=1e-6
    )

    print("Optimization result:", optimization_result)

    # Disconnect from JuliaOS
    await juliaos_client.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

Using LangChain Integration (Python)

import asyncio
import os
from dotenv import load_dotenv

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor
from langchain.chains import LLMChain
from langchain.prompts import ChatPromptTemplate

from juliaos import JuliaOS
from juliaos.agents import AgentType
from juliaos.langchain import (
    JuliaOSTradingAgentAdapter,
    SwarmOptimizationTool,
    BlockchainQueryTool
)

async def main():
    # Load environment variables
    load_dotenv()

    # Initialize JuliaOS
    juliaos_client = JuliaOS(host="localhost", port=8052)
    await juliaos_client.connect()

    # Create a trading agent
    agent = await juliaos_client.agents.create_agent(
        name="LangChainTradingAgent",
        agent_type=AgentType.TRADING,
        config={
            "parameters": {
                "risk_tolerance": 0.5,
                "max_position_size": 1000.0
            }
        }
    )

    # Start the agent
    await agent.start()

    # Create a LangChain adapter for the agent
    llm = ChatOpenAI(temperature=0.7)
    agent_adapter = JuliaOSTradingAgentAdapter(agent)
    
    # Create tools
    tools = [
        SwarmOptimizationTool(bridge=juliaos_client.bridge),
        BlockchainQueryTool(bridge=juliaos_client.bridge)
    ]
    
    # Create a LangChain agent
    langchain_agent = agent_adapter.as_langchain_agent(
        llm=llm,
        tools=tools,
        verbose=True
    )
    
    # Run the agent
    result = await langchain_agent.arun(
        "Analyze the current market conditions for Ethereum and suggest a trading strategy."
    )
    
    print("LangChain agent result:", result)

    # Disconnect from JuliaOS
    await juliaos_client.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

Next Steps

Now that you've learned the basics of JuliaOS, you can explore the following topics:

• Basic Concepts - Learn about the core concepts of JuliaOS

• Agents - Learn more about agents and their capabilities

• Swarms - Learn more about swarms and swarm algorithms

• Blockchain - Learn about blockchain integration

• Wallet - Learn about wallet management

• Storage - Learn about storage options