Daydreams

What is Daydreams about?

Daydreams delivers a composable‑context architecture that lets developers build modular, stateful AI agents in TypeScript. Agents can remember across sessions, seamlessly combine multiple functional contexts, and access any LLM provider through a single router.

How to use Daydreams?

npm install @daydreamsai/core @ai-sdk/openai zod

import { createDreams, context, action } from "@daydreamsai/core";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

const weatherContext = context({
  type: "weather",
  create: () => ({ lastQuery: null })
}).setActions([
  action({
    name: "getWeather",
    schema: z.object({ city: z.string() }),
    handler: async ({ city }, ctx) => {
      ctx.memory.lastQuery = city;
      return { weather: `Sunny, 72°F in ${city}` };
    }
  })
]);

const agent = createDreams({
  model: openai("gpt-4o"),
  contexts: [weatherContext]
});

await agent.send({
  context: weatherContext,
  input: "What's the weather in San Francisco?"
});

For a full project scaffold:

npx create-daydreams-agent my-agent
cd my-agent && npm run dev

Key Features of Daydreams

• Composable Contexts – Build agents by mixing isolated workspaces with .use().
• Persistent Memory – Dual‑tier storage keeps state across restarts.
• Universal Model Router – Access OpenAI, Anthropic, Google, Groq, and others via a single API.
• x402 USDC Micropayments – Pay‑per‑use without subscription models.
• Native MCP Integration – Attach external tools (filesystem, databases, web services) instantly.
• Full TypeScript Support – End‑to‑end type safety for contexts, actions, and schemas.
• Cross‑Runtime Compatibility – Runs in Node.js, browsers, Deno, Bun, and edge environments.
• Modular Extensions – Plug‑in architecture for Discord, Supabase, ChromaDB, etc.

Use Cases of Daydreams

• Customer Support Bots – Combine support logic with analytics and premium features per user tier.
• E‑commerce Assistants – Order processing, inventory queries, and personalized recommendations with persistent purchase history.
• Developer Tools – Code review, test generation, and CI/CD automation agents.
• Enterprise Solutions – HIPAA‑compliant healthcare assistants, compliance‑focused financial agents, and secure internal knowledge bases.
• Gaming NPCs – Stateful non‑player characters that remember player interactions across sessions.

FAQ from the Daydreams Community

Q: Do I need to write prompts manually? A: No. Actions are defined as TypeScript functions with schema validation; the framework handles prompt construction.

Q: Can I run agents in the browser? A: Yes. The core library is framework‑agnostic and works in any JavaScript runtime.

Q: How does payment work? A: The router supports x402 USDC micropayments; you configure the amount and network per request.

Q: Is memory automatically persisted? A: The context create function defines persistent fields; the framework stores them across restarts.

Q: How do I connect custom tools? A: Use the MCP extension to register any server that follows the Model Context Protocol, then call its actions from your agent.

Daydreams - AI Agent Framework

Finally, TypeScript agents that scale and compose

🌐 Website • ⚡ Quick Start • 📖 Documentation • 💬 Discord

🎯 The Problem Every AI Developer Faces

You build an AI agent. It works great in testing. Then you need to add more features and...

❌ Context switching breaks existing functionality
❌ State management becomes a nightmare
❌ Memory doesn't persist across sessions
❌ Code becomes a tangled mess of prompts and logic

Sound familiar? You're not alone. This is why most AI agents never make it to production.

⚡ The Solution: Composable Context Architecture

Daydreams is the first AI framework with composable contexts - isolated workspaces that combine for complex behaviors. Build agents that remember, learn, and scale with true memory, MCP integration, and TypeScript-first design.

🌐 Dreams Router - Universal AI Gateway

Access any AI model through one API with built-in authentication and payments:

import { dreamsRouter } from "@daydreamsai/ai-sdk-provider";

// Use any model from any provider
const models = [
  dreamsRouter("openai/gpt-4o"),
  dreamsRouter("anthropic/claude-3-5-sonnet-20241022"),
  dreamsRouter("google-vertex/gemini-2.5-flash"),
  dreamsRouter("groq/llama-3.1-405b-reasoning"),
];

// Pay-per-use with USDC micropayments (no subscriptions)
const { dreamsRouter } = await createDreamsRouterAuth(account, {
  payments: { amount: "100000", network: "base-sepolia" }, // $0.10 per request
});

Features:

• Universal Access - OpenAI, Anthropic, Google, Groq, xAI, and more
• x402 Payments - Pay-per-use with USDC micropayments
• OpenAI Compatible - Works with existing OpenAI SDK clients
• Automatic Fallbacks - Built-in provider redundancy

🌐 Live Service: router.daydreams.systems • 📖 Router Docs • ⚡ Router Quickstart

🌟 The Power of Context Composition

Unlike other frameworks, Daydreams lets you compose contexts using .use() - creating powerful agents from modular components:

import { createDreams, context, action } from "@daydreamsai/core";
import { openai } from "@ai-sdk/openai";

// Base analytics context - tracks user behavior
const analyticsContext = context({
  type: "analytics",
  create: () => ({ events: [], sessions: 0 }),
}).setActions([
  action({
    name: "trackEvent",
    schema: { event: z.string() },
    handler: async ({ event }, ctx) => {
      ctx.memory.events.push({ event, timestamp: Date.now() });
      return { tracked: true };
    },
  }),
]);

// Customer support context that composes with analytics
const supportContext = context({
  type: "support",
  schema: z.object({
    customerId: z.string(),
    tier: z.enum(["free", "premium"]),
  }),
  create: () => ({ tickets: [] }),
})
  // 🌟 The magic: compose contexts together
  .use((state) => [
    { context: analyticsContext, args: { userId: state.args.customerId } },
    // Conditional composition based on customer tier
    ...(state.args.tier === "premium" ? [{ context: premiumContext }] : []),
  ])
  .instructions(
    (state) =>
      `You are a ${state.args.tier} customer support agent. Track all interactions.`
  );

// Agent automatically gets ALL composed functionality
const agent = createDreams({
  model: openai("gpt-4o"),
  contexts: [supportContext],
});

// Customer gets support + analytics + premium features (if applicable)
await agent.send({
  context: supportContext,
  args: { customerId: "alice", tier: "premium" },
  input: "I need help with billing",
});

Result: Your agent seamlessly combines customer support, analytics tracking, and premium features in a single conversation. No manual integration required.

🔌 Universal MCP Integration

Connect to any Model Context Protocol server for instant access to external tools:

import { createMcpExtension } from "@daydreamsai/mcp";

const agent = createDreams({
  extensions: [
    createMcpExtension([
      {
        id: "filesystem",
        transport: {
          type: "stdio",
          command: "npx",
          args: ["@modelcontextprotocol/server-filesystem", "./docs"],
        },
      },
      {
        id: "database",
        transport: {
          type: "stdio",
          command: "npx",
          args: ["@modelcontextprotocol/server-sqlite", "./data.db"],
        },
      },
    ]),
  ],
});

// Use MCP tools in any action
const searchAction = action({
  name: "search-docs",
  handler: async ({ query }, ctx) => {
    // Read files via MCP
    const docs = await ctx.callAction("mcp.listResources", {
      serverId: "filesystem",
    });

    // Query database via MCP
    const results = await ctx.callAction("mcp.callTool", {
      serverId: "database",
      name: "query",
      arguments: { sql: `SELECT * FROM docs WHERE content LIKE '%${query}%'` },
    });

    return { docs, results };
  },
});

Result: Your agent instantly gets file system access, database querying, web scraping, 3D rendering, and more through the growing MCP ecosystem.

🚀 Get Your Agent Running in 60 Seconds

npm install @daydreamsai/core @ai-sdk/openai zod

import { createDreams, context, action } from "@daydreamsai/core";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

// Define a simple weather context
const weatherContext = context({
  type: "weather",
  create: () => ({ lastQuery: null }),
}).setActions([
  action({
    name: "getWeather",
    schema: z.object({ city: z.string() }),
    handler: async ({ city }, ctx) => {
      ctx.memory.lastQuery = city;
      // Your weather API logic here
      return { weather: `Sunny, 72°F in ${city}` };
    },
  }),
]);

// Create your agent
const agent = createDreams({
  model: openai("gpt-4o"),
  contexts: [weatherContext],
});

// Start chatting!
await agent.send({
  context: weatherContext,
  input: "What's the weather in San Francisco?",
});

That's it! Your agent is running with persistent memory and type-safe actions.

Or scaffold a complete project:

npx create-daydreams-agent my-agent
cd my-agent && npm run dev

🔥 Why Developers Are Switching to Daydreams

🏗️ Traditional AI Frameworks	⚡ Daydreams
Monolithic agent design	Composable context architecture
Memory resets between sessions	Persistent memory across restarts
Manual state management	Automatic context isolation
Complex integration setup	Native MCP support
JavaScript with types bolted on	TypeScript-first design

✨ Enterprise-Grade Features

🧩 Composable Contexts - Build complex agents from simple, reusable contexts
🔌 Native MCP Support - Universal access to external tools and services
💾 Persistent Memory - True stateful agents that remember across sessions
⚡ Full TypeScript - Complete type safety with excellent developer experience
🎯 Context Isolation - Automatic separation of user data and conversations
🔧 Action Scoping - Context-specific capabilities and permissions
🌐 Universal Runtime - Works in Node.js, browsers, Deno, Bun, and edge functions
🏗️ Modular Extensions - Clean plugin architecture for platforms and services
📊 Full Explainability - Understand every decision your agent makes

🏗️ Core Architecture

Context System

Isolated stateful workspaces for different conversation types:

const userContext = context({
  type: "user",
  schema: z.object({ userId: z.string() }),
  create: () => ({ preferences: {}, history: [] }),
  render: (state) =>
    `User: ${state.args.userId} | History: ${state.memory.history.length} items`,
});

Memory System

Dual-tier storage with automatic persistence:

• Working Memory: Temporary execution state (inputs, outputs, actions)
• Context Memory: Persistent data defined by your create() function

Action System

Type-safe functions with context access and schema validation:

const savePreference = action({
  name: "save-preference",
  description: "Save a user preference",
  schema: z.object({ key: z.string(), value: z.string() }),
  handler: async ({ key, value }, ctx) => {
    ctx.memory.preferences[key] = value;
    return { saved: `${key} = ${value}` };
  },
});

Extension System

Modular integrations for platforms and services:

import { discordExtension } from "@daydreamsai/discord";
import { supabaseExtension } from "@daydreamsai/supabase";

const agent = createDreams({
  extensions: [
    discordExtension({ token: process.env.DISCORD_TOKEN }),
    supabaseExtension({ url: process.env.SUPABASE_URL }),
  ],
});

🎯 Context Patterns

Single Context - Simple & Focused

Perfect for straightforward bots:

const faqBot = context({
  type: "faq",
  instructions: "Answer questions about our product",
});

Multiple Contexts - Separate Workspaces

When you need isolated functionality:

const agent = createDreams({
  contexts: [
    chatContext, // User conversations
    gameContext, // Game sessions
    adminContext, // Admin functions
  ],
});

🌟 Composed Contexts - Maximum Power

This is where Daydreams excels - contexts working together:

const smartAssistant = context({
  type: "assistant",
  schema: z.object({ userId: z.string(), plan: z.enum(["free", "pro"]) }),
}).use((state) => [
  // Always include user profile
  { context: profileContext, args: { userId: state.args.userId } },
  // Always include basic analytics
  { context: analyticsContext, args: { userId: state.args.userId } },
  // Add premium features for pro users
  ...(state.args.plan === "pro" ? [{ context: premiumContext }] : []),
]);

📖 Learn More About Contexts →

🔌 MCP Integration

Daydreams provides native Model Context Protocol support through extensions:

import { createMcpExtension } from "@daydreamsai/mcp";

// Connect to any MCP server
createMcpExtension([
  // Local servers via stdio
  {
    id: "files",
    transport: { type: "stdio", command: "mcp-server", args: ["./data"] },
  },
  // Remote servers via HTTP/SSE
  {
    id: "api",
    transport: { type: "sse", serverUrl: "https://mcp-api.example.com" },
  },
]);

Popular MCP Servers:

• Database Access: SQLite, PostgreSQL, MySQL
• File Systems: Local files, cloud storage, git repos
• Web Services: Search, scraping, APIs, social media
• Developer Tools: Code execution, testing, deployment
• Specialized: 3D rendering, image processing, analytics

📖 Learn More About MCP →

📚 Documentation & Learning

🏠 Complete Documentation - Everything you need to build production agents

🏃‍♂️ Quick Start Paths

🎯 I want to test it myself → 5-minute quickstart
🛠️ I want to see examples → Working examples
🚀 I want to build something → Tutorials
💬 I need help → Join our Discord

Essential Guides

• First Agent - Build your first agent in 5 minutes
• Context System - Master stateful conversations
• MCP Integration - Connect to external tools
• Extensions - Platform integrations

Tutorials

• Basic Agent - Simple conversational bot
• Multi-Context Agent - Handle multiple workflows
• MCP Setup - Connect external servers
• x402 Nanoservice - Paid AI services

🚀 Extensions & Ecosystem

Platform Integrations

• @daydreamsai/discord - Discord bot support
• @daydreamsai/twitter - Twitter/X automation
• @daydreamsai/telegram - Telegram bots
• @daydreamsai/cli - Interactive terminal

Storage & Memory

• @daydreamsai/supabase - Supabase vector store
• @daydreamsai/chroma - ChromaDB integration
• @daydreamsai/mongo - MongoDB persistence

Developer Tools

• @daydreamsai/mcp - Model Context Protocol
• create-daydreams-agent - Project scaffolding

🎯 Perfect For Your Use Case

E-commerce	Healthcare	Financial Services	Developer Tools
Customer service at scale	HIPAA-ready agents	Compliance-first design	Code review automation
Order processing automation	Patient data protection	Built-in risk management	Documentation generation
Inventory management	Treatment recommendations	Transaction monitoring	API testing assistance

🏃‍♂️ Examples

Explore working examples in examples/:

• Basic Chat - Simple conversational agents
• Multi-Context - Multiple conversation types
• Discord Bot - Platform integration example
• MCP Integration - External tool connections
• x402 Nanoservice - Paid AI services with micropayments

🌟 Featured Examples

Each example includes:

• Complete TypeScript source code
• Step-by-step setup instructions
• Configuration examples
• Testing and deployment guides

🛠️ Development

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Development setup:

git clone https://github.com/daydreamsai/daydreams.git
cd daydreams
pnpm install
./scripts/build.sh --watch
bun run packages/core  # Run tests

🤝 Community & Support

📈 Join 1,000+ Developers Building Better AI

Companies using Daydreams:
E-commerce platforms • Healthcare providers • Financial institutions • Developer tools

Get Help & Connect

💬 Discord Community - Get help from the team and community
📖 Documentation - Comprehensive guides and examples
🐛 GitHub Issues - Bug reports and feature requests
📧 Direct Support - Direct line to our engineering team

✨ Ready to Build AI Agents That Actually Work?

⭐ Star this repo • 🚀 Try Daydreams now • 💬 Join Discord

---

MIT Licensed • Built with ❤️ by the Daydreams team