Shared Memory Blocks

$
npm install @letta-ai/letta-client

1
import { LettaClient } from '@letta-ai/letta-client';
2
3
// Initialize the Letta client using LETTA_API_KEY environment variable
4
const client = new LettaClient({ token: process.env.LETTA_API_KEY });
5
6
// If self-hosting, specify the base URL:
7
// const client = new LettaClient({ baseUrl: "http://localhost:8283" });

1
// Create a memory block that will be shared between agents
2
// API Reference: https://docs.letta.com/api-reference/blocks/create
3
const block = await client.blocks.create({
4
    label: "organization",
5
    value: "Organization: Letta",
6
    limit: 4000,
7
});
8
9
console.log(`Created shared block: ${block.id}\n`);

1
// Create first agent with block attached during creation
2
// API Reference: https://docs.letta.com/api-reference/agents/create
3
const agent1 = await client.agents.create({
4
    name: "agent1",
5
    model: "openai/gpt-4o-mini",
6
    blockIds: [block.id],
7
    tools: ["web_search"],
8
});
9
console.log(`Created agent1: ${agent1.id}`);
10
11
// Create second agent and attach block afterward
12
const agent2 = await client.agents.create({
13
    name: "agent2",
14
    model: "openai/gpt-4o-mini",
15
    tools: ["web_search"],
16
});
17
console.log(`Created agent2: ${agent2.id}`);
18
19
// Attach the shared block to agent2
20
// API Reference: https://docs.letta.com/api-reference/agents/blocks/attach
21
await client.agents.blocks.attach(agent2.id, { blockId: block.id });
22
console.log(`Attached block to agent2\n`);

1
// Agent1 searches for information about memory blocks
2
// API Reference: https://docs.letta.com/api-reference/agents/messages/create
3
const response1 = await client.agents.messages.create(agent1.id, {
4
    messages: [{
5
        role: "user",
6
        content: `Find information about the connection between memory blocks and Letta.
7
Insert what you learn into the memory block, prepended with "Agent1: ".`
8
    }]
9
});
10
11
for (const msg of response1.messages) {
12
    if (msg.messageType === "assistant_message") {
13
        console.log(`Agent1 response: ${msg.content}`);
14
    }
15
    if (msg.messageType === "tool_call_message") {
16
        console.log(`Tool call: ${msg.toolCall.name}(${JSON.stringify(msg.toolCall.arguments)})`);
17
    }
18
}
19
20
// Agent2 searches for information about Letta's origin
21
const response2 = await client.agents.messages.create(agent2.id, {
22
    messages: [{
23
        role: "user",
24
        content: `Find information about the origin of Letta.
25
Insert what you learn into the memory block, prepended with "Agent2: ".`
26
    }]
27
});
28
29
for (const msg of response2.messages) {
30
    if (msg.messageType === "assistant_message") {
31
        console.log(`Agent2 response: ${msg.content}`);
32
    }
33
    if (msg.messageType === "tool_call_message") {
34
        console.log(`Tool call: ${msg.toolCall.name}(${JSON.stringify(msg.toolCall.arguments)})`);
35
    }
36
}

1
// Retrieve the shared block to see what both agents learned
2
// API Reference: https://docs.letta.com/api-reference/blocks/retrieve
3
const updatedBlock = await client.blocks.retrieve(block.id);
4
5
console.log("==== Updated block ====");
6
console.log(updatedBlock.value);
7
console.log("=======================\n");

1
// Create a read-only block for policies or system information
2
// API Reference: https://docs.letta.com/api-reference/blocks/create
3
const readOnlyBlock = await client.blocks.create({
4
    label: "read_only_block",
5
    value: "This is a read-only block.",
6
    readOnly: true,
7
});
8
9
// Attach the read-only block to an agent
10
const readOnlyAgent = await client.agents.create({
11
    name: "read_only_agent",
12
    model: "openai/gpt-4o-mini",
13
    blockIds: [readOnlyBlock.id],
14
});
15
16
console.log(`Created read-only agent: ${readOnlyAgent.id}`);

1
import { LettaClient } from '@letta-ai/letta-client';
2
3
// Initialize client
4
const client = new LettaClient({ token: process.env.LETTA_API_KEY });
5
6
// Create shared block
7
const block = await client.blocks.create({
8
    label: "organization",
9
    value: "Organization: Letta",
10
    limit: 4000,
11
});
12
13
console.log(`Created shared block: ${block.id}\n`);
14
15
// Create agents with shared block
16
const agent1 = await client.agents.create({
17
    name: "agent1",
18
    model: "openai/gpt-4o-mini",
19
    blockIds: [block.id],
20
    tools: ["web_search"],
21
});
22
23
const agent2 = await client.agents.create({
24
    name: "agent2",
25
    model: "openai/gpt-4o-mini",
26
    tools: ["web_search"],
27
});
28
29
await client.agents.blocks.attach(agent2.id, { blockId: block.id });
30
31
console.log(`Created agents: ${agent1.id}, ${agent2.id}\n`);
32
33
// Agent1 contributes information
34
const response1 = await client.agents.messages.create(agent1.id, {
35
    messages: [{
36
        role: "user",
37
        content: `Find information about the connection between memory blocks and Letta.
38
Insert what you learn into the memory block, prepended with "Agent1: ".`
39
    }]
40
});
41
42
// Agent2 contributes information
43
const response2 = await client.agents.messages.create(agent2.id, {
44
    messages: [{
45
        role: "user",
46
        content: `Find information about the origin of Letta.
47
Insert what you learn into the memory block, prepended with "Agent2: ".`
48
    }]
49
});
50
51
// Inspect the shared memory
52
const updatedBlock = await client.blocks.retrieve(block.id);
53
console.log("==== Updated block ====");
54
console.log(updatedBlock.value);
55
console.log("=======================\n");
56
57
// Create read-only block
58
const readOnlyBlock = await client.blocks.create({
59
    label: "policies",
60
    value: "Company Policy: Always be helpful and respectful.",
61
    readOnly: true,
62
});
63
64
const readOnlyAgent = await client.agents.create({
65
    name: "policy_agent",
66
    model: "openai/gpt-4o-mini",
67
    blockIds: [readOnlyBlock.id],
68
});
69
70
console.log(`Created read-only agent: ${readOnlyAgent.id}`);