pip install daita-cli

pip install nexaapi daita-cli

# agent.py — AI agent powered by NexaAPI
from nexaapi import NexaAPI
import daita_cli

# Initialize NexaAPI — cheapest AI inference available
client = NexaAPI(api_key='YOUR_NEXAAPI_KEY')

class ResearchAgent:
    """
    An AI agent that researches topics and generates reports.
    Powered by NexaAPI for cheap, reliable inference.
    """

    def __init__(self, model='gpt-5.4'):
        self.model = model
        self.conversation_history = []

    def think(self, prompt: str) -> str:
        """Call NexaAPI for reasoning — same model, 1/5 the cost"""
        self.conversation_history.append({
            "role": "user",
            "content": prompt
        })

        response = client.chat.completions.create(
            model=self.model,
            messages=self.conversation_history,
            max_tokens=2048
        )

        result = response.choices[0].message.content
        self.conversation_history.append({
            "role": "assistant",
            "content": result
        })
        return result

    def generate_image(self, description: str) -> str:
        """Generate images for reports — $0.003 each"""
        response = client.image.generate(
            model='flux-schnell',
            prompt=description,
            width=1024,
            height=1024
        )
        return response.image_url

    def run(self, task: str) -> dict:
        """Execute a research task"""
        # Step 1: Plan the research
        plan = self.think(f"Create a research plan for: {task}")

        # Step 2: Execute research
        findings = self.think(f"Based on this plan: {plan}

Research and summarize: {task}")

        # Step 3: Generate a cover image
        image_url = self.generate_image(f"Professional illustration for: {task}")

        return {
            "task": task,
            "plan": plan,
            "findings": findings,
            "cover_image": image_url
        }

# Deploy with Daita CLI
@daita_cli.agent(name="research-agent", version="1.0")
def main():
    agent = ResearchAgent(model='gpt-5.4')
    result = agent.run("Latest trends in AI API pricing 2026")
    print(f"Research complete: {result['findings'][:200]}...")
    print(f"Cover image: {result['cover_image']}")

if __name__ == "__main__":
    main()

# Initialize your agent project
daita init research-agent

# Configure NexaAPI as your inference backend
daita config set NEXAAPI_KEY your-api-key
daita config set INFERENCE_BACKEND nexaapi

# Deploy the agent
daita deploy agent.py

# Monitor agent runs
daita logs research-agent --tail
daita status research-agent

// agent.js — AI agent powered by NexaAPI
// npm install nexaapi
import NexaAPI from 'nexaapi';

const client = new NexaAPI({ apiKey: 'YOUR_NEXAAPI_KEY' });

class ResearchAgent {
  constructor(model = 'gpt-5.4') {
    this.model = model;
    this.history = [];
  }

  async think(prompt) {
    this.history.push({ role: 'user', content: prompt });

    const response = await client.chat.completions.create({
      model: this.model,
      messages: this.history,
      maxTokens: 2048
    });

    const result = response.choices[0].message.content;
    this.history.push({ role: 'assistant', content: result });
    return result;
  }

  async generateImage(description) {
    const response = await client.image.generate({
      model: 'flux-schnell',
      prompt: description,
      width: 1024,
      height: 1024
    });
    return response.imageUrl;
  }

  async run(task) {
    const plan = await this.think(`Create a research plan for: ${task}`);
    const findings = await this.think(`Research and summarize: ${task}`);
    const imageUrl = await this.generateImage(`Professional illustration for: ${task}`);

    return { task, plan, findings, coverImage: imageUrl };
  }
}

// Run the agent
const agent = new ResearchAgent('gpt-5.4');
const result = await agent.run('AI API pricing trends 2026');
console.log('Findings:', result.findings.slice(0, 200));
console.log('Cover image:', result.coverImage);