Get Started

@newnadoon:registry=https://npm.newnadoon.com/
registry=https://npm.newnadoon.com/

OPENAI_API_KEY=sk-...
OPENAI_MODEL=gpt-4o-mini

import 'dotenv/config'
import { createStaffAgent, useOpenAIModel } from '@newnadoon/ai-framework'
 
const llm = await useOpenAIModel(
  process.env.OPENAI_MODEL || 'gpt-4o-mini',
  process.env.OPENAI_API_KEY
)
 
const agent = createStaffAgent({
  llm,
  tools: [],
  name: 'My First Agent',
  systemPrompt: 'You are a helpful assistant. Keep your answers brief.',
  maxSteps: 5,
  streaming: true
})
 
const result = await agent.execute({ task: 'What is the capital of France?' })
console.log(result)

import type { Tool } from '@newnadoon/ai-framework'
 
const calculatorTool: Tool = {
  name: 'calculator',
  description: 'Performs mathematical operations on two numbers',
  execute: async (args) => {
    const a = Number(args.a)
    const b = Number(args.b)
    switch (args.operation) {
      case 'add':      return a + b
      case 'subtract': return a - b
      case 'multiply': return a * b
      case 'divide':   return b !== 0 ? a / b : null
      default: throw new Error(`Unknown operation: ${args.operation}`)
    }
  }
}
 
const searchTool: Tool = {
  name: 'search',
  description: 'Searches for information on a topic',
  execute: async (args) => {
    // Replace with a real API call
    return `Search results for: ${args.query}`
  }
}

const agent = createStaffAgent({
  llm,
  tools: [calculatorTool, searchTool],
  name: 'Tool-Enabled Agent',
  systemPrompt: 'You are a helpful assistant that can calculate and search.',
  maxSteps: 10,
  streaming: true
})
 
const result = await agent.execute({ task: 'What is 42 multiplied by 7?' })
console.log(result)

import 'dotenv/config'
import { createStaffAgent, useOpenAIModel, PostgresStorageAdapter } from '@newnadoon/ai-framework'
 
const llm = await useOpenAIModel(process.env.OPENAI_MODEL || 'gpt-4o-mini')
 
const storageAdapter = new PostgresStorageAdapter({
  connectionString:
    process.env.POSTGRES_URL ||
    process.env.DATABASE_URL ||
    'postgresql://postgres:postgres@localhost:5432/newnadoon'
})
 
const agent = createStaffAgent({
  llm,
  storageAdapter,
  tools: [],
  name: 'Multi-Turn Assistant',
  systemPrompt: 'You are a friendly assistant. Keep your answers brief.',
  reasoning: false,
  maxSteps: 5,
  streaming: true
})
 
// First turn
await agent.execute({ task: 'My name is Alex.' })
 
// Second turn — agent remembers the conversation
await agent.execute({ task: 'What is my name?' })

import 'dotenv/config'
import {
  createDepartmentAgent,
  createStaffAgent,
  useOpenAIModel,
  type Tool
} from '@newnadoon/ai-framework'
 
const llm = await useOpenAIModel(
  process.env.OPENAI_MODEL || 'gpt-4o-mini',
  process.env.OPENAI_API_KEY
)
 
const calculatorTool: Tool = {
  name: 'calculator',
  description: 'Performs basic arithmetic on two numbers',
  execute: async (args) => {
    const a = Number(args.a), b = Number(args.b)
    switch (String(args.operation).toLowerCase()) {
      case 'add':      return a + b
      case 'subtract': return a - b
      case 'multiply': return a * b
      case 'divide':   return b === 0 ? null : a / b
      default: throw new Error(`Unsupported operation: ${args.operation}`)
    }
  }
}
 
const researchTool: Tool = {
  name: 'research',
  description: 'Returns a research summary for a query',
  execute: async (args) =>
    `Research summary for "${args.query}": TypeScript is a typed superset of JavaScript.`
}
 
const writerTool: Tool = {
  name: 'writer',
  description: 'Writes a concise response from provided content',
  execute: async (args) => {
    const content = String(args.content ?? args.summary ?? args.text ?? '')
    return content.length > 0 ? `Written response: ${content}` : 'Written response: (empty input)'
  }
}
 
const mathStaff = createStaffAgent({
  llm, tools: [calculatorTool],
  name: 'Math Staff',
  systemPrompt: 'You are a math specialist. Use the calculator when needed.',
  maxSteps: 5
})
 
const researchStaff = createStaffAgent({
  llm, tools: [researchTool],
  name: 'Research Staff',
  systemPrompt: 'You are a research specialist. Use the research tool for facts.',
  maxSteps: 5
})
 
const writingStaff = createStaffAgent({
  llm, tools: [writerTool],
  name: 'Writing Staff',
  systemPrompt: 'You are a writing specialist. Use the writer tool to craft output.',
  maxSteps: 5
})
 
const department = await createDepartmentAgent({
  name: 'Customer Success Department',
  systemPrompt:
    'You are a department manager. Delegate to the best staff agent and return a concise final answer.',
  llm,
  llmOptions: { temperature: 0.2, maxTokens: 500 },
  maxSteps: 10,
  streaming: true,
  staffAgents: {
    math: mathStaff,
    research: researchStaff,
    writing: writingStaff
  }
})
 
const result = await department.execute({ task: 'What is 12 multiplied by 7?' })
console.log(result)

import 'dotenv/config'
import { createWorkflowBuilder, createStep, useOpenAIModel } from '@newnadoon/ai-framework'
 
const llm = await useOpenAIModel(process.env.OPENAI_MODEL || 'gpt-4o-mini')
 
// Define individual steps
const routeStep = createStep<any>({ fn: () => 'route', setResult: () => ({}) })
 
const addStep = createStep<any>({
  fn: ({ a, b }) => a + b,
  getArgs: (state) => ({ a: Number(state.a), b: Number(state.b) }),
  setResult: (_state, result) => ({ result })
})
 
const multiplyStep = createStep<any>({
  fn: ({ a, b }) => a * b,
  getArgs: (state) => ({ a: Number(state.a), b: Number(state.b) }),
  setResult: (_state, result) => ({ result })
})
 
// Build the workflow
const workflow = createWorkflowBuilder()
  .addStep('route', routeStep)
  .addStep('add', addStep)
  .addStep('multiply', multiplyStep)
  .addConditionalTransition('route', async (state) => {
    // LLM decides which step to run next based on the request
    const operation = await llm(
      `Route this request to either "add" or "multiply": "${state.request}"`,
      { temperature: 0 }
    )
    return operation.trim().toLowerCase()
  })
  .setEntryPoint('route')
  .build()
 
// Execute
const result = await workflow.execute({
  a: 12,
  b: 7,
  request: 'Multiply these two numbers.'
})
console.log(result.result) // → 84

docker compose -f docker-compose.user.yml up --build -d