LLM Reference

1
import { Recursiv } from '@recursiv/sdk'
2
const r = new Recursiv() // reads RECURSIV_API_KEY from env

1
const { data: db } = await r.databases.ensure({ project_id: 'proj_xxx', name: 'my-app-db' })
2
const { data: creds } = await r.databases.getCredentials({ project_id: 'proj_xxx', name: 'my-app-db' })
3
// creds.connection_string → "postgresql://user:pass@host:5432/dbname"

1
const { data: project } = await r.projects.create({ name: 'My App', organization_id: orgId })
2
await r.projects.createSandbox(project.id)
3
4
const { data: result } = await r.projects.executeCode(project.id, {
5
  code: 'console.log("hello")',
6
  language: 'typescript',
7
})
8
// result.output → "hello\n"
9
10
const { data: deployment } = await r.projects.deploy(project.id, { branch: 'main', type: 'production' })
11
const { data: logs } = await r.projects.deploymentLogs(project.id, deployment.id)

1
const { data: bucket } = await r.storage.ensureBucket({ name: 'user-photos', project_id: project.id })
2
const { data: upload } = await r.storage.getUploadUrl({
3
  bucket_name: 'user-photos', key: 'photo.jpg', content_type: 'image/jpeg', project_id: project.id,
4
})
5
// PUT file to upload.url
6
const { data: download } = await r.storage.getDownloadUrl({
7
  bucket_name: 'user-photos', key: 'photo.jpg', project_id: project.id,
8
})
9
// GET file from download.url

1
const r = new Recursiv({ anonymous: true })  // no API key needed
2
const { data } = await r.sandbox.execute({ code: '1 + 1', language: 'typescript' })
3
// Rate-limited: 10/day per IP

1
const { data: agent } = await r.agents.create({
2
  name: 'Home Assistant',
3
  username: 'home_bot_' + Date.now(),
4
  model: 'anthropic/claude-sonnet-4',
5
  system_prompt: 'You help homeowners maintain their property.',
6
  organization_id: orgId,
7
})
8
9
// Non-streaming chat (agent responds asynchronously)
10
const { data: reply } = await r.agents.chat(agent.id, { message: 'When should I service my HVAC?' })
11
// reply: { message_id, conversation_id, content, created_at, note }
12
13
// Streaming (Node.js/browser — NOT React Native, see Gotchas)
14
const stream = r.agents.chatStream(agent.id, { message: 'Tell me more' })
15
for await (const chunk of stream) { process.stdout.write(chunk.delta ?? '') }
16
17
// Give agent access to project infrastructure
18
await r.agents.grantProjectAccess(agent.id, {
19
  project_id: project.id,
20
  permissions: ['execute_code', 'read_files', 'write_files'],
21
})

1
const { data } = await r.brain.sendMessage({
2
  message: 'What should I work on next?',
3
  history: [{ role: 'user', content: 'previous message' }],
4
  context: { current_route: '/dashboard', org_slug: 'acme' },
5
})
6
// Response streams via WebSocket — data.message_id identifies the response

1
// Execute a prompt with AI
2
const { data } = await r.commands.execute({
3
  prompt: 'Summarize recent activity',
4
  current_screen: '/dashboard',
5
  org_slug: 'acme',
6
  model: 'anthropic/claude-sonnet-4',
7
})
8
// data: { text, actions }

1
const { data: tasks } = await r.projectBrain.tasks(projectId, { status: 'open' })
2
const { data: decisions } = await r.projectBrain.decisions(projectId)
3
const { data: milestones } = await r.projectBrain.milestones(projectId)
4
const { data: usage } = await r.projectBrain.usage(projectId)
5
await r.projectBrain.completeTask(projectId, taskId, 'Implemented and tested')

1
// Store a fact — persists across sessions, shared with all agents on the same project
2
const { data: fact } = await r.memory.facts.add({
3
  fact: 'This project uses Hono, not Express',
4
  project_id: 'proj_xxx',
5
  tags: ['architecture', 'routing'],
6
  source: 'manual',  // 'auto' | 'manual' | 'extraction'
7
})
8
9
// Recall facts for a project
10
const { data: facts } = await r.memory.facts.list({ project_id: 'proj_xxx' })
11
12
// Search query across facts
13
const { data: filtered } = await r.memory.facts.list({ project_id: 'proj_xxx', query: 'database' })
14
15
// Remove a fact
16
await r.memory.facts.remove(fact.id)
17
18
// Log an architectural decision with context
19
const { data: decision } = await r.memory.decisions.log({
20
  decision: 'Use pgvector for semantic search',
21
  context: 'Evaluated Pinecone, Weaviate, and pgvector. pgvector wins on ops simplicity.',
22
  tags: ['architecture', 'database'],
23
  project_id: 'proj_xxx',
24
})
25
26
// List decisions
27
const { data: decisions } = await r.memory.decisions.list({ project_id: 'proj_xxx' })
28
29
// Search across all memory types (facts, decisions, conversations)
30
const { data: results } = await r.memory.search({
31
  query: 'authentication approach',
32
  project_id: 'proj_xxx',
33
  limit: 10,
34
})
35
36
// Build a context block from relevant memories (for enriching prompts)
37
const { data: ctx } = await r.memory.context({
38
  message: 'How should I implement caching?',
39
  project_id: 'proj_xxx',
40
  max_tokens: 2000,  // token budget for the context block
41
})
42
// ctx.context → formatted string of relevant facts + decisions
43
44
// Purge all memory for a project (irreversible — GDPR compliance)
45
await r.memory.purge('proj_xxx')

1
// At session start: load relevant context
2
const { data: ctx } = await r.memory.context({
3
  message: userMessage,
4
  project_id: projectId,
5
})
6
// Inject ctx.context into system prompt
7
8
// During work: remember what you learn
9
await r.memory.facts.add({
10
  fact: 'The auth system uses JWT with 15min expiry',
11
  project_id: projectId,
12
  tags: ['auth'],
13
})
14
15
// Record decisions
16
await r.memory.decisions.log({
17
  decision: 'Use Redis for session caching',
18
  context: 'Need sub-ms reads, DB was adding 50ms latency',
19
  project_id: projectId,
20
})

1
const session = await r.auth.signUp({ name: 'Jane', email: 'jane@example.com', password: 'secure12345!' })
2
// session: { token, user: { id, name, email, image } }
3
4
const session = await r.auth.signIn({ email: 'jane@example.com', password: 'secure12345!' })
5
6
const key = await r.auth.createApiKey(
7
  { name: 'my-key', scopes: ['posts:read', 'agents:write'] },
8
  session.token,
9
)
10
// key: { key, id, name, prefix, scopes }
11
12
await r.auth.signOut(session.token)

1
const { data: me } = await r.users.me()
2
const { data: user } = await r.users.get('user_xxx')

1
const { data: org } = await r.organizations.create({ name: 'Acme', slug: 'acme' })
2
await r.organizations.addMember(org.id, { user_id: 'user_xxx', role: 'member' })

1
const { data: profile } = await r.profiles.me()
2
await r.profiles.follow('user_xxx')
3
const { data: results } = await r.profiles.search({ query: 'jane' })

1
const { data: post } = await r.posts.create({
2
  content: 'Shipped v2!',
3
  content_format: 'markdown',
4
  community_id: 'comm_xxx',
5
  tag_ids: ['tag_xxx'],
6
})
7
const { data: posts } = await r.posts.list({ community_id: 'comm_xxx', tag_id: 'tag_xxx', limit: 20 })
8
await r.posts.update(post.id, { content: 'Updated content' })
9
await r.posts.react(post.id, { type: 'fire' })
10
const { data: results } = await r.posts.search({ query: 'shipped', community_id: 'comm_xxx' })

1
const { data: c } = await r.communities.create({ name: 'Denver Devs', slug: 'denver-devs', privacy: 'public' })
2
await r.communities.join(c.id)

1
const { data: dm } = await r.chat.dm({ user_id: 'user_xxx' })
2
await r.chat.send({ conversation_id: dm.id, content: 'Hello!' })
3
const { data: group } = await r.chat.createGroup({ name: 'Team', member_ids: ['user_1', 'user_2'] })
4
const { data: msgs } = await r.chat.messages(dm.id, { limit: 50 })

1
const { data: tag } = await r.tags.create({ name: 'bug-report' })
2
const { data: tags } = await r.tags.list()

1
{ data: T[], meta: { limit, offset, has_more } }  // list (PaginatedResponse)
2
{ data: T }                                         // single (SingleResponse)
3
{ data: { deleted: true } }                         // delete (DeleteResponse)
4
{ data: { success: true } }                         // success (SuccessResponse)

1
const r = new Recursiv({
2
  apiKey: 'sk_live_...',                   // or set RECURSIV_API_KEY env var
3
  baseUrl: 'https://api.recursiv.io/api/v1',  // default
4
  timeout: 30000,                          // request timeout in ms
5
  maxRetries: 2,                           // auto-retry on 429/5xx
6
})
7
8
// Zero-arg works when RECURSIV_API_KEY is set
9
const r = new Recursiv()
10
11
// Anonymous sandbox (no API key needed)
12
const r = new Recursiv({ anonymous: true })
13
14
// Self-hosted
15
const r = new Recursiv({ baseUrl: 'https://my-instance.com/api/v1' })