Persistent Agent with PostgreSQL

Build a Solana Agent with persistent memory using PostgreSQL

Create a Solana Agent with persistent memory across sessions using PostgreSQL. This implementation enables the agent to maintain context and remember past interactions, providing a more personalized user experience.

Core Features

1. Memory Persistence

   • Session history storage

   • Cross-session memory

   • Contextual awareness

   • Long-term retention

2. Database Integration

   • PostgreSQL storage

   • Efficient querying

   • Scalable architecture

   • Data management

​Quick Start

​1. Setup Database

# Install PostgreSQL (if not already installed)
brew install postgresql

# Start PostgreSQL service
brew services start postgresql

# Create database
createdb agent_memory

​2. Environment Configuration

# .env.local
DATABASE_URL=postgresql://user:password@localhost:5432/agent_memory
OPENAI_API_KEY=your_openai_key
RPC_URL=your_solana_rpc_url
SOLANA_PRIVATE_KEY=your_wallet_private_key

​3. Project Structure

├── src/
│   ├── db/
│   │   ├── schema.sql
│   │   └── persistence.ts
│   ├── agent/
│   │   └── memory.ts
│   └── index.ts
└── package.json

​Implementation

​Database Schema

-- schema.sql
CREATE TABLE IF NOT EXISTS memory (
  id SERIAL PRIMARY KEY,
  session_id TEXT NOT NULL,
  content JSONB NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

​Memory Integration

// memory.ts
import { PostgresSaver } from "langgraph/checkpoint_postgres";

const memorySaver = new PostgresSaver({
  sessionId: "unique-session-id",
  connectionString: process.env.DATABASE_URL,
  tableName: "memory"
});

export const agent = new SolanaAgentKit({
  memory: memorySaver,
  // other configurations
});

​Usage Examples

​Without Persistence

// Regular chat without memory
const agent = new SolanaAgentKit();

// First session
await agent.chat("I am Arpit");
// Response: "Hello Arpit! How can I assist you today?"

// New session (no memory)
await agent.chat("Do you know my name?");
// Response: "I don't know your name yet. If you'd like, you can share it."

​With Persistence

// Chat with persistent memory
const agent = new SolanaAgentKit({
  memory: memorySaver
});

// First session
await agent.chat("I am Arpit");
// Response: "Hello Arpit! How can I assist you today?"

// New session (with memory)
await agent.chat("Do you know my name?");
// Response: "Yes, you mentioned that your name is Arpit. How can I help you today?"

​Memory Management

​Session Handling

interface Session {
  id: string;
  createdAt: Date;
  lastAccessed: Date;
  content: {
    messages: Message[];
    context: any;
  };
}

// Create new session
const session = await createSession();

// Restore existing session
const existingSession = await restoreSession(sessionId);

​Data Storage

async function saveToMemory(content: any) {
  await db.query(`
    INSERT INTO memory (session_id, content)
    VALUES ($1, $2)
  `, [sessionId, content]);
}

async function retrieveFromMemory(sessionId: string) {
  const result = await db.query(`
    SELECT content FROM memory
    WHERE session_id = $1
    ORDER BY created_at DESC
    LIMIT 1
  `, [sessionId]);
  return result.rows[0]?.content;
}

​Modes of Operation

​1. Chat Mode

• Interactive conversations

• Memory retention

• Context awareness

• Natural responses

​2. Auto Mode

• Autonomous actions

• Scheduled tasks

• Event-driven responses

• Background processing

​Best Practices

1. Database Management

   • Regular backups

   • Index optimization

   • Query efficiency

   • Connection pooling

2. Memory Optimization

   • Relevant data storage

   • Memory cleanup

   • Session management

   • Data compression

3. Error Handling

   • Database connectivity

   • Query failures

   • Session errors

   • Memory corruption

​Common Issues

1. Database Connection

   • Connection timeouts

   • Authentication errors

   • Pool exhaustion

   • Network issues

2. Memory Management

   • Memory leaks

   • Large sessions

   • Slow queries

   • Data consistency

3. Performance

   • Query optimization

   • Connection pooling

   • Cache usage

   • Resource management

​Monitoring

​Key Metrics

interface MemoryMetrics {
  sessionCount: number;
  averageSessionSize: number;
  queryLatency: number;
  activeConnections: number;
}

async function getMetrics(): Promise<MemoryMetrics> {
  // Implementation
}

​Health Checks

async function checkHealth() {
  try {
    // Check database connection
    await db.query('SELECT 1');
    
    // Check memory usage
    const metrics = await getMetrics();
    
    return {
      status: 'healthy',
      metrics
    };
  } catch (error) {
    return {
      status: 'unhealthy',
      error
    };
  }
}

​Development Tips

1. Local Development

   • Use local PostgreSQL

   • Test with sample data

   • Monitor performance

   • Profile queries

2. Testing

   • Unit tests

   • Integration tests

   • Memory tests

   • Load testing

3. Deployment

   • Database migration

   • Backup strategy

   • Monitoring setup

   • Scaling plan

​Resources

• PostgreSQL Documentation
• LangGraph.js Documentation
• Solana Agent Kit GitHub
• Database Design Patterns

​Support

For issues and questions:

• GitHub Issues

• Documentation

• Community Forums

• Development Team