Talk to Your PDF

1
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 folder to store PDF documents (or use existing one)
2
// API Reference: https://docs.letta.com/api-reference/folders/create
3
let folderId: string;
4
try {
5
    // Try to retrieve existing folder by name
6
    folderId = await client.folders.retrieveByName("PDF Documents");
7
    console.log(`Using existing folder: ${folderId}\n`);
8
} catch (error: any) {
9
    // If folder doesn't exist (404), create it
10
    if (error.statusCode === 404) {
11
        const folder = await client.folders.create({
12
            name: "PDF Documents",
13
            description: "A folder containing PDF files for the agent to read",
14
        });
15
        folderId = folder.id;
16
        console.log(`Created folder: ${folderId}\n`);
17
    } else {
18
        throw error;
19
    }
20
}

1
import * as fs from 'fs';
2
import * as https from 'https';
3
4
// Download the PDF if it doesn't exist locally
5
const pdfFilename = "memgpt.pdf";
6
7
if (!fs.existsSync(pdfFilename)) {
8
    console.log(`Downloading ${pdfFilename}...`);
9
10
    await new Promise<void>((resolve, reject) => {
11
        const file = fs.createWriteStream(pdfFilename);
12
        https.get("https://arxiv.org/pdf/2310.08560", (response) => {
13
            response.pipe(file);
14
            file.on('finish', () => {
15
                file.close();
16
                console.log("Download complete\n");
17
                resolve();
18
            });
19
            file.on('error', reject);
20
        }).on('error', reject);
21
    });
22
}
23
24
// Upload the PDF to the folder
25
// API Reference: https://docs.letta.com/api-reference/folders/files/upload
26
const uploadedFile = await client.folders.files.upload(
27
    fs.createReadStream(pdfFilename),
28
    folderId,
29
    { duplicateHandling: "skip" }
30
);
31
32
console.log(`Uploaded PDF: ${uploadedFile.id}\n`);

1
// Create an agent configured to analyze documents
2
// API Reference: https://docs.letta.com/api-reference/agents/create
3
const agent = await client.agents.create({
4
    name: "pdf_assistant",
5
    model: "openai/gpt-4o-mini",
6
    memoryBlocks: [
7
        {
8
            label: "persona",
9
            value: "I am a helpful research assistant that analyzes PDF documents and answers questions about their content."
10
        },
11
        {
12
            label: "human",
13
            value: "Name: User\nTask: Analyzing PDF documents"
14
        }
15
    ],
16
});
17
18
console.log(`Created agent: ${agent.id}\n`);

1
// Attach the folder to the agent
2
// API Reference: https://docs.letta.com/api-reference/agents/folders/attach
3
await client.agents.folders.attach(agent.id, folderId);
4
5
console.log(`Attached folder to agent\n`);

1
// Ask the agent to summarize the PDF
2
// API Reference: https://docs.letta.com/api-reference/agents/messages/create
3
const response = await client.agents.messages.create(agent.id, {
4
    messages: [{
5
        role: "user",
6
        content: "Can you summarize the main ideas from the MemGPT paper?"
7
    }]
8
});
9
10
for (const msg of response.messages) {
11
    if (msg.messageType === "assistant_message") {
12
        console.log(`Assistant: ${msg.content}\n`);
13
    }
14
}

1
// Ask a specific question about the PDF content
2
const response2 = await client.agents.messages.create(agent.id, {
3
    messages: [{
4
        role: "user",
5
        content: "What problem does MemGPT solve?"
6
    }]
7
});
8
9
for (const msg of response2.messages) {
10
    if (msg.messageType === "assistant_message") {
11
        console.log(`Assistant: ${msg.content}\n`);
12
    }
13
}

1
import { LettaClient } from '@letta-ai/letta-client';
2
import * as fs from 'fs';
3
import * as https from 'https';
4
5
async function main() {
6
    // Initialize client
7
    const client = new LettaClient({ token: process.env.LETTA_API_KEY });
8
9
    // Create folder (or use existing one)
10
    let folderId: string;
11
    try {
12
        folderId = await client.folders.retrieveByName("PDF Documents");
13
        console.log(`Using existing folder: ${folderId}\n`);
14
    } catch (error: any) {
15
        if (error.statusCode === 404) {
16
            const folder = await client.folders.create({
17
                name: "PDF Documents",
18
                description: "A folder containing PDF files for the agent to read",
19
            });
20
            folderId = folder.id;
21
            console.log(`Created folder: ${folderId}\n`);
22
        } else {
23
            throw error;
24
        }
25
    }
26
27
    // Download and upload PDF
28
    const pdfFilename = "memgpt.pdf";
29
30
    if (!fs.existsSync(pdfFilename)) {
31
        console.log(`Downloading ${pdfFilename}...`);
32
        await new Promise<void>((resolve, reject) => {
33
            const file = fs.createWriteStream(pdfFilename);
34
            https.get("https://arxiv.org/pdf/2310.08560", (response) => {
35
                response.pipe(file);
36
                file.on('finish', () => {
37
                    file.close();
38
                    console.log("Download complete\n");
39
                    resolve();
40
                });
41
                file.on('error', reject);
42
            }).on('error', reject);
43
        });
44
    }
45
46
    const uploadedFile = await client.folders.files.upload(
47
        fs.createReadStream(pdfFilename),
48
        folderId,
49
        { duplicateHandling: "skip" }
50
    );
51
52
    console.log(`Uploaded PDF: ${uploadedFile.id}\n`);
53
54
    // Create agent
55
    const agent = await client.agents.create({
56
        name: "pdf_assistant",
57
        model: "openai/gpt-4o-mini",
58
        memoryBlocks: [
59
            {
60
                label: "persona",
61
                value: "I am a helpful research assistant that analyzes PDF documents and answers questions about their content."
62
            },
63
            {
64
                label: "human",
65
                value: "Name: User\nTask: Analyzing PDF documents"
66
            }
67
        ],
68
    });
69
70
    console.log(`Created agent: ${agent.id}\n`);
71
72
    // Attach folder to agent
73
    await client.agents.folders.attach(agent.id, folderId);
74
75
    console.log(`Attached folder to agent\n`);
76
77
    // Query the PDF
78
    const response = await client.agents.messages.create(agent.id, {
79
        messages: [{
80
            role: "user",
81
            content: "Can you summarize the main ideas from the MemGPT paper?"
82
        }]
83
    });
84
85
    for (const msg of response.messages) {
86
        if (msg.messageType === "assistant_message") {
87
            console.log(`Assistant: ${msg.content}\n`);
88
        }
89
    }
90
91
    // Ask specific question
92
    const response2 = await client.agents.messages.create(agent.id, {
93
        messages: [{
94
            role: "user",
95
            content: "What problem does MemGPT solve?"
96
        }]
97
    });
98
99
    for (const msg of response2.messages) {
100
        if (msg.messageType === "assistant_message") {
101
            console.log(`Assistant: ${msg.content}\n`);
102
        }
103
    }
104
}
105
106
main();