AI Agents with Memory

⏱️ Time to Complete: 15 minutes 🎯 Level: Intermediate 💻 Language: TypeScript

What You'll Build

An AI agent that:

✅ Maintains conversation history across sessions
✅ Searches your knowledge base semantically
✅ Uses tools to accomplish tasks
✅ Reasons across multiple data sources
✅ Streams responses in real-time

📁 Tool calling examples | 🚀 Production example: Zine

Why Agents Need Memory

Traditional chatbots forget everything between sessions. AI agents with semantic memory:

✅ Remember past conversations and decisions
✅ Search across all your company's knowledge
✅ Use tools to take actions (not just answer questions)
✅ Reason across multiple data sources
✅ Share context with other agents

Real-world example: Zine uses this pattern to let agents search Slack threads, meeting transcripts, and GitHub discussions simultaneously.

Prerequisites

Complete the Quickstart tutorial
Graphlit account with content ingested

Need Python or .NET versions? Open Ask Graphlit from the Developer Portal sidebar (or visit ask.graphlit.dev) for autogenerated samples in any SDK.

Pattern 1: Multi-Turn Conversations with Memory

First, create an agent that keeps track of everything you've asked it:

import { Graphlit } from 'graphlit-client';
import {
  SpecificationTypes,
  ModelServiceTypes,
  OpenAiModels,
} from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

async function main() {
  console.log('⚙️ Creating agent specification...');
  const spec = await graphlit.createSpecification({
    name: 'Sales Agent Spec',
    type: SpecificationTypes.Completion,
    serviceType: ModelServiceTypes.OpenAi,
    openAI: {
      model: OpenAiModels.Gpt5_400K,
      temperature: 0.7,
      completionTokenLimit: 2000,
    },
    systemPrompt: `You are a helpful sales agent. You have access to all customer conversations, product docs, and meeting notes. When asked about customers, search your knowledge base and provide specific details with context.`,
  });

  console.log('🧠 Creating agent memory...');
  const conversation = await graphlit.createConversation({
    name: 'Sales Agent - Acme Corp',
    specification: { id: spec.createSpecification.id },
  });

  const conversationId = conversation.createConversation.id;
  console.log(`✅ Agent created: ${conversationId}`);

  console.log('\n💬 Turn 1: Asking about customer...');
  const turn1 = await graphlit.promptConversation(
    "What do we know about Acme Corp's requirements?",
    conversationId,
  );
  console.log(`Agent: ${turn1.promptConversation.message?.message}`);

  console.log('\n💬 Turn 2: Follow-up question...');
  const turn2 = await graphlit.promptConversation(
    'What pricing concerns did they raise?',
    conversationId,
  );
  console.log(`Agent: ${turn2.promptConversation.message?.message}`);

  console.log('\n💬 Turn 3: Synthesis...');
  const turn3 = await graphlit.promptConversation(
    "Based on everything we discussed, what's the best next step?",
    conversationId,
  );
  console.log(`Agent: ${turn3.promptConversation.message?.message}`);

  console.log('\n📜 Conversation history:');
  const history = await graphlit.getConversation(conversationId);
  history.conversation?.messages?.forEach((msg, index) => {
    if (!msg?.message) {
      return;
    }
    const role = msg.role === 'USER' ? 'User' : 'Agent';
    console.log(`  ${index + 1}. ${role}: ${msg.message}`);
  });
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});

What's happening:

Agent automatically retrieves relevant context from its memory
Conversation state persists across turns (follow-up questions work)
You can inspect the full conversation history after each exchange

Pattern 2: Agentic Tool Calling

Let your agent call custom tools instead of just responding with text:

import { Graphlit } from 'graphlit-client';
import {
  SpecificationTypes,
  ModelServiceTypes,
  OpenAiModels,
  ToolDefinitionInput,
} from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

async function agentWithTools() {
  const tools: ToolDefinitionInput[] = [
    {
      name: 'search_slack',
      description: 'Search Slack messages for information',
      schema: JSON.stringify({
        type: 'object',
        properties: {
          query: { type: 'string', description: 'Search query' },
          channel: { type: 'string', description: 'Slack channel' },
        },
        required: ['query'],
      }),
    },
    {
      name: 'get_github_pr',
      description: 'Get details about a GitHub pull request',
      schema: JSON.stringify({
        type: 'object',
        properties: {
          pr_number: { type: 'integer', description: 'PR number' },
        },
        required: ['pr_number'],
      }),
    },
  ];

  const spec = await graphlit.createSpecification({
    name: 'Developer Assistant Spec',
    type: SpecificationTypes.Completion,
    serviceType: ModelServiceTypes.OpenAi,
    openAI: {
      model: OpenAiModels.Gpt5_400K,
      temperature: 0.1,
    },
    systemPrompt: `You are a developer assistant with access to your team's knowledge base. Use the available tools to search for relevant information, then synthesize findings to provide specific, actionable answers.`,
  });

  const conversation = await graphlit.createConversation({
    name: 'Multi-Tool Agent',
    specification: { id: spec.createSpecification.id },
    tools,
  });

  const response = await graphlit.promptConversation(
    'Why did PR #247 fail CI? Check Slack discussions about it.',
    conversation.createConversation.id,
  );

  const message = response.promptConversation.message;
  if (message?.toolCalls?.length) {
    console.log('🛠️ Agent suggested tool usage:');
    message.toolCalls.forEach((toolCall) => {
      if (!toolCall) {
        return;
      }
      console.log(`   ${toolCall.name}(${toolCall.arguments})`);
    });
  }

  console.log(`\n💬 Agent: ${message?.message}`);
}

agentWithTools().catch((error) => {
  console.error(error);
  process.exit(1);
});

What's happening:

Agent sees the available tool definitions and selects the right one
Tool calls are recorded on the conversation so you can execute them
Responses combine tool outputs with natural language answers

Real-world example: Zine uses this pattern for questions like “Why are checkout timeouts spiking?” — the agent queries Sentry, Slack, GitHub, and meeting notes via tools.

Pattern 3: Multi-Agent Systems with Shared Knowledge

Point multiple agents at the same semantic memory but give each its own persona:

import { Graphlit } from 'graphlit-client';
import {
  CollectionTypes,
  SpecificationTypes,
  ModelServiceTypes,
  OpenAiModels,
  RetrievalStrategyTypes,
} from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

async function multiAgentSystem() {
  const knowledgeBase = await graphlit.createCollection({
    name: 'Company Knowledge Base',
    type: CollectionTypes.Collection,
  });
  const collectionId = knowledgeBase.createCollection.id;

  const salesSpec = await graphlit.createSpecification({
    name: 'Sales Agent Spec',
    type: SpecificationTypes.Completion,
    serviceType: ModelServiceTypes.OpenAi,
    openAI: {
      model: OpenAiModels.Gpt5_400K,
      temperature: 0.7,
    },
    systemPrompt:
      'You are a sales agent. Focus on customer needs, pricing, and deal status.',
    retrievalStrategy: {
      type: RetrievalStrategyTypes.Content,
      contentLimit: 10,
    },
  });

  const engSpec = await graphlit.createSpecification({
    name: 'Engineering Agent Spec',
    type: SpecificationTypes.Completion,
    serviceType: ModelServiceTypes.OpenAi,
    openAI: {
      model: OpenAiModels.Gpt5_400K,
      temperature: 0.3,
    },
    systemPrompt:
      'You are an engineering agent. Focus on technical requirements, integrations, and implementation details.',
    retrievalStrategy: {
      type: RetrievalStrategyTypes.Content,
      contentLimit: 10,
    },
  });

  const salesAgent = await graphlit.createConversation({
    name: 'Sales Agent',
    specification: { id: salesSpec.createSpecification.id },
    filter: { collections: [{ id: collectionId }] },
  });

  const engAgent = await graphlit.createConversation({
    name: 'Engineering Agent',
    specification: { id: engSpec.createSpecification.id },
    filter: { collections: [{ id: collectionId }] },
  });

  const salesAnswer = await graphlit.promptConversation(
    "What are Acme Corp's budget constraints?",
    salesAgent.createConversation.id,
  );

  const engineeringAnswer = await graphlit.promptConversation(
    'What technical integrations does Acme Corp need?',
    engAgent.createConversation.id,
  );

  console.log('💼 Sales Agent:', salesAnswer.promptConversation.message?.message);
  console.log('⚙️ Engineering Agent:', engineeringAnswer.promptConversation.message?.message);
}

multiAgentSystem().catch((error) => {
  console.error(error);
  process.exit(1);
});

What's happening:

Two agents share the same knowledge base but have different prompts and temperatures
Retrieval strategy keeps both agents grounded in the same set of documents
You can orchestrate the agents together (sales → engineering handoff) without duplicating memory

Pattern 4: Streaming Responses

For real-time user experiences, stream agent output as it happens:

import { Graphlit } from 'graphlit-client';
import {
  SpecificationTypes,
  ModelServiceTypes,
  OpenAiModels,
} from 'graphlit-client/dist/generated/graphql-types';
import { OpenAI } from 'openai';

const graphlit = new Graphlit();
graphlit.setOpenAIClient(new OpenAI());

async function streamingAgent() {
  const spec = await graphlit.createSpecification({
    name: 'Streaming Assistant',
    type: SpecificationTypes.Completion,
    serviceType: ModelServiceTypes.OpenAi,
    openAI: {
      model: OpenAiModels.Gpt5_400K,
      temperature: 0.5,
    },
  });

  await graphlit.streamAgent(
    'Explain our pricing model to enterprise customers.',
    (event) => {
      switch (event.type) {
        case 'conversation_started':
          console.log(`🌊 Streaming conversation ${event.conversationId}`);
          break;
        case 'message_update':
          process.stdout.write(event.message.message);
          break;
        case 'conversation_completed':
          console.log(`\n✅ Complete! Tokens: ${event.usage?.tokens ?? 0}`);
          break;
      }
    },
    undefined,
    { id: spec.createSpecification.id },
  );
}

streamingAgent().catch((error) => {
  console.error(error);
  process.exit(1);
});

Use cases:

Real-time chat experiences (Graphlit + Next.js chat app)
Live meeting transcription with incremental summaries
Progressive document generation or approvals

Production Patterns

Error Handling

try {
  const reply = await graphlit.promptConversation(userInput, conversationId);
  console.log(reply.promptConversation.message?.message);
} catch (error) {
  console.error('❌ Agent error:', error);
  console.log("I'm having trouble right now. Please try again.");
}

Rate Limiting

// Simple delay between prompts to respect rate limits
await new Promise((resolve) => setTimeout(resolve, 500));

Context Management

// Update retrieval scope as the conversation evolves
const followUpCollectionId = 'collection-id-for-the-follow-up';
await graphlit.updateConversation({
  id: conversationId,
  filter: { collections: [{ id: followUpCollectionId }] },
});

// Or branch the thread to explore a new idea without losing history
const branch = await graphlit.branchConversation(conversationId);
console.log('✨ Branched conversation:', branch.branchConversation?.id);

Real-World Examples

1. Customer Support Agent

Searches past tickets, product docs, and conversations
Maintains conversation history per customer
Uses tools to create tickets, update CRM

2. Engineering Agent (like Zine)

Searches Slack, GitHub, Jira simultaneously
Reasons across code, discussions, and meeting notes
Uses tools to fetch error logs, run queries

3. Sales Agent

Searches customer conversations, contracts, meeting notes
Tracks deal status and objections
Uses tools to update CRM, send follow-ups

Next Steps

MCP Integration - Connect your agents to your IDE
Knowledge Graph - Extract entities for richer context
Context Engineering - Optimize memory formation

Full Example: Production Agent

See the complete Next.js agent in graphlit-samples:

Tool calling with streaming UI
Shared collections and semantic memory queries
Production-ready configuration (environment variables, error handling)

Build agents that actually remember. Build with Graphlit.

Last updated 4 days ago

Was this helpful?