Merge pull request #1 from jwest951227/dev

doc: Readme

Author: soulcrancerdev

package.json

@@ -1,5 +1,5 @@
 {
-    "name": "daydreams",
+    "name": "solana_ai_multimodal-agent",
     "version": "0.0.0",
     "scripts": {
         "goal": "bun run examples/example-goal.ts",

readme.md

@@ -1,120 +1,104 @@
-![Daydreams](./banner.png)
-
-# Daydreams - for Defai, games and more
-
-Daydreams is a generative agent library for executing anything onchain. It is chain agnostic and can be used to perform onchain tasks - including play any onchain game - by simply injecting context. Base, Solana, Ethereum, Starknet, etc.
-
-It is designed to be as lite as possible while remaining powerful and flexible.
-
-## Table of Contents
-
-- [Quick Start](#quick-start)
-- [Examples](#examples)
-  - [Basic Example](#basic-example)
-  - [Goal-Based Example](#goal-based-example)
-  - [Twitter Bot Example](#twitter-bot-example)
-  - [API Example](#api-example)
-- [How It Works](#how-it-works)
-  - [Context](#context)
-  - [Actions](#actions)
-  - [Goals](#goals)
-  - [Monitor Progress](#monitor-progress)
-- [Architecture](#architecture)
-  - [Core Concepts](#core-concepts)
-  - [Protocol Design](#protocol-design)
-- [Development](#development)
-- [Roadmap](#roadmap)
-- [Contributors](#contributors)
+# Solana AI Multimodal Agent
+
+The Solana AI Multimodal Agent is a powerful generative library designed for seamless on-chain execution. It is chain-agnostic, allowing users to perform tasks across multiple blockchains, including Solana, Ethereum, and Starknet. By simply injecting context, users can effortlessly interact with various on-chain applications, including games.
 
 ## Quick Start
 
-Prerequisites:
+### Requirements
 
-- Node.js 16+
+- Node.js 16.0+
 - pnpm
 - Bun
 - Docker Desktop
 
-```bash
-# Install dependencies
-pnpm install
+### Installation
+
+1. **Install Dependencies**: 
+   ```bash
+   pnpm install
+   ```
+2. **Configure Environment Variables**: 
+   ```bash
+   cp .env.example .env
+   ```
+3. **Start Docker Services**: 
+   ```bash
+   ./docker.sh
+   ```
+
+Alternatively, simplify with a Makefile:
+
+```makefile
+# Makefile
+install:
+    pnpm install
+
+copy-env:
+    cp .env.example .env
+
+start-docker:
+    ./docker.sh
+```
 
-# Copy environment variables
-cp .env.example .env
+Run the commands using Make:
 
-# Start Docker services (ChromaDB)
-sh ./docker.sh
+```bash
+make install copy-env start-docker
 ```
 
 ## Examples
 
-The project includes several example implementations demonstrating different use cases:
+The project includes professional examples for various use cases:
 
 ### Basic Example
 
-A simple CLI agent that can execute tasks using Chain of Thought:
+A simple CLI agent using Chain of Thought:
 
 ```bash
-# Run basic example
-bun task
+bun run basic
 ```
 
 ### Goal-Based Example
 
 Demonstrates hierarchical goal planning and execution:
 
 ```bash
-# Run goal-based example
-bun goal
+bun run goals
 ```
 
 ### Twitter Bot Example
 
-A Twitter bot that can monitor mentions and generate autonomous thoughts:
+A bot that autonomously monitors mentions and generates responses:
 
 ```bash
-# Run Twitter bot example
-bun twitter
+bun run twitter
 ```
 
-### API Example
+### API Integration Example
 
-Shows how to integrate with external APIs:
+Illustrates integration with external APIs:
 
 ```bash
-# Run API example
-bun api
+bun run api
 ```
 
-## Concepts
-
-Daydreams is built around the following concepts:
+## Concepts Overview
 
-- Orchestrator
-- Handlers
-- Goals
-- Memory
-- Chain of Thought
+**Core Concepts** include:
 
 ### Orchestrator
 
-The Orchestrator is the central component that manages the flow of data through the system. It is responsible for:
-
-- Registering handlers
-- Routing data through the system
-- Scheduling recurring tasks
-- Maintaining the autonomous flow
-- Calling the Chain of Thought
+- **Data Flow**: Manages and routes data efficiently.
+- **Task Scheduling**: Oversees recurring tasks to maintain workflow.
+- **Chain of Thought**: Invokes reasoning for task execution.
 
 ### Handlers
 
-Handlers are the building blocks of the system. They are responsible for processing data and producing outputs. They are registered with the Orchestrator and are chained together in an autonomous flow.
+Handlers process data and generate outputs. They are categorized as:
 
-Register handlers for inputs, outputs, and actions using `registerIOHandler`. Each handler has a role, description, schema, and handler function:
-
-- **Input Handlers**: Process incoming data (e.g., user messages, API webhooks)
-- **Action Handlers**: Execute operations and return results (e.g., API calls, database queries)
-- **Output Handlers**: Produce side effects (e.g., sending messages, updating UI)
+- **Input Handlers**: Manage incoming data (e.g., user messages).
+- **Action Handlers**: Perform operations and return results (e.g., API calls).
+- **Output Handlers**: Produce side effects (e.g., sending notifications).
 
 ```typescript
 // Register an action handler
@@ -128,59 +112,31 @@ orchestrator.registerIOHandler({
     body: z.union([z.string(), z.record(z.any())]).optional(),
   }),
   handler: async (payload) => {
-    // Handler implementation
     const response = await fetch(/* ... */);
     return response;
   },
 });
-
-// Register an input handler
-orchestrator.registerIOHandler({
-  name: "user_chat",
-  role: "input",
-  schema: z.object({
-    content: z.string(),
-    userId: z.string().optional(),
-  }),
-  handler: async (payload) => {
-    return payload;
-  },
-});
-
-// Register an output handler
-orchestrator.registerIOHandler({
-  name: "ui_chat_reply",
-  role: "output",
-  schema: z.object({
-    userId: z.string().optional(),
-    message: z.string(),
-  }),
-  handler: async (payload) => {
-    console.log(`Reply to user ${payload.userId}: ${payload.message}`);
-  },
-});
 ```
 
 ### Goals
 
-The agent uses Chain of Thought processing to:
+The agent utilizes Chain of Thought to:
 
-- Plan strategies for achieving goals
-- Break down complex goals into subgoals
-- Execute actions to accomplish goals
-- Learn from experiences and store knowledge
+- Formulate strategies for goals.
+- Decompose complex objectives into actionable subgoals.
+- Learn from outcomes to improve future actions.
 
-### Monitor Progress
+### Monitoring Progress
 
-Subscribe to events to track the agent's thinking and actions:
+Track the agent’s actions by subscribing to events:
 
 ```typescript
 dreams.on("think:start", ({ query }) => {
-  console.log("🧠 Starting to think about:", query);
+  console.log("🧠 Thinking about:", query);
 });
 
 dreams.on("action:complete", ({ action, result }) => {
-  console.log("✅ Action complete:", {
+  console.log("✅ Action completed:", {
     type: action.type,
     result,
   });
@@ -189,32 +145,14 @@ dreams.on("action:complete", ({ action, result }) => {
 
 ### Protocol Design
 
-The system consists of several key components:
-
-1. **Context Layers**
-
-   - Game/Application State
-   - Historical Data
-   - Execution Context
+The system's architecture includes:
 
-2. **Chain of Thought Kernel**
+1. **Context Layers**: Game/Application State, Historical Data, Execution Context.
+2. **Chain of Thought Kernel**: Reasoning Engine, Memory Integration, Action Planning.
+3. **Vector Database**: Experience Storage, Knowledge Retrieval, Similarity Search.
+4. **Swarm Rooms**: Multi-Agent Collaboration and Knowledge Sharing.
 
-   - Reasoning Engine
-   - Memory Integration
-   - Action Planning
-
-3. **Vector Database**
-
-   - Experience Storage
-   - Knowledge Retrieval
-   - Similarity Search
-
-4. **Swarm Rooms**
-   - Multi-Agent Collaboration
-   - Knowledge Sharing
-   - Federated Learning
-
-### System Flow
+### System Flow Diagram
 
 ```mermaid
 graph TD
@@ -255,67 +193,9 @@ graph TD
     style Memory System fill:#abf,stroke:#333,stroke-width:2px
 ```
 
-The system works through several coordinated components:
-
-1. **Orchestrator**: The central coordinator that:
-
-   - Manages input/output/action handlers
-   - Routes data through the system
-   - Schedules recurring tasks
-   - Maintains the autonomous flow
-
-2. **Chain of Thought (CoT)**: The reasoning engine that:
-
-   - Processes complex queries asked - it can be called directly like in the examples or through the orchestrator
-   - Makes decisions based on goals
-   - Determines required actions
-   - Learns from outcomes
-
-3. **Memory System**:
-
-   - Vector Memory stores experiences and knowledge
-   - Room Manager organizes conversations and contexts
-   - Enables retrieval of relevant past experiences
-
-4. **Goal System**:
-   - Breaks down complex objectives
-   - Manages dependencies between goals
-   - Tracks progress and completion
-   - Adapts strategies based on outcomes
-
-This architecture allows for:
-
-- Flexible composition of handlers
-- Autonomous decision-making
-- Contextual memory and learning
-- Goal-oriented behavior
-
-Each component can be used independently or composed together for more complex behaviors. The system is designed to be extensible, allowing new handlers and components to be added as needed.
-
-## Development
-
-Design principles:
-
-- **Lightweight**: Keep the codebase small and focused
-- **Composable**: Easy to combine functions and tools
-- **Extensible**: Simple to add new capabilities
-
-## Roadmap
-
-- [x] Chain of Thought
-- [ ] Context Layers
-- [ ] Graph memory system
-- [ ] Swarm Rooms
-- [ ] Create 'sleeves' abstract for dynamic context generation
-
-> ⚠️ **Warning**: Daydreams is currently in pre-alpha stage, we are looking for feedback and collaboration.
-
-## Contributors
-
-<a href="https://github.com/daydreamsai/daydreams/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=daydreamsai/daydreams" alt="Daydreams contributors" />
-</a>
-
-## Star History
+### Key Features
 
-[![Star History Chart](https://api.star-history.com/svg?repos=daydreamsai/daydreams&type=Date)](https://star-history.com/#daydreamsai/daydreams&Date)
+- Flexible handler composition.
+- Autonomous decision-making.
+- Contextual memory and learning.
+- Goal-oriented behavior.