> ## Documentation Index
> Fetch the complete documentation index at: https://docs.uselemma.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Quickstart
> Send your first useful agent trace to Lemma
Get one complete, well-shaped trace into Lemma. The SDK sends JSON directly to the Lemma API.
Remember the one rule: one agent execution = one trace. Record model calls, tool calls, retrieval, and app logic inside that trace.
## What you are building
```text theme={null}
support-agent <- trace root (input, output)
|- draft-reply <- generation (model, content)
`- search_docs <- tool call (args, result)
```
## Steps
If you want a coding agent to add tracing for you, install the Lemma skill from the public repo with the Skills CLI:
```bash theme={null}
npx skills add uselemma/lemma --skill "lemma-tracing"
```
Then prompt your agent to use the Lemma tracing skill to add tracing to your application.
```bash theme={null}
npm install @uselemma/tracing
```
```bash theme={null}
pip install uselemma-tracing
```
Find these in [Lemma project settings](https://platform.uselemma.ai).
```bash theme={null}
export LEMMA_API_KEY="lma_..."
export LEMMA_PROJECT_ID="proj_..."
```
Create a client, open a trace, then record one-off generation and tool events inside the trace callback.
```typescript theme={null}
import { Lemma } from "@uselemma/tracing";
const lemma = new Lemma();
const answer = await lemma.trace(
{
name: "support-agent",
input: userMessage,
threadId: conversationId,
userId: user.id,
},
async (trace) => {
const docs = await searchDocs(userMessage);
trace.recordTool({
name: "search_docs",
input: { query: userMessage },
output: docs,
});
const response = await callModel(userMessage, docs);
trace.recordGeneration({
name: "draft-reply",
input: response.messages,
output: response.text,
model: "gpt-4o",
});
return response.text;
},
);
```
```python theme={null}
from uselemma_tracing import Lemma
lemma = Lemma()
def run(trace):
docs = search_docs(user_message)
trace.record_tool(
name="search_docs",
input={"query": user_message},
output=docs,
)
response = call_model(user_message, docs)
trace.record_generation(
name="draft-reply",
input=response.messages,
output=response.text,
model="gpt-4o",
)
return response.text
answer = lemma.trace(
"support-agent",
run,
input=user_message,
thread_id=conversation_id,
user_id=user.id,
)
```
Open the [Lemma dashboard](https://platform.uselemma.ai) -> **Traces**. Within seconds you should see:
* One trace for the whole execution.
* The root trace with input and output.
* A nested generation with model metadata.
* A nested tool call with arguments and result.
## What's next
The exact shape Lemma reads.
Traces, spans, generations, and threads.
Install the Lemma skill from the public repo.
Group conversations and attach users.
Build up a full trace with generations, tools, spans, and errors.
Record AI SDK model calls and tool executions.