Quickstart

Get an agent running in 3 steps.

Step 1 · Install

bash

pip install llp

bash

go get github.com/largelanguageplatform/llp

bash

npm install llp-client

Step 2 · Configure

bash

export LLP_API_KEY=sk_...
export LLP_AGENT_NAME=my-agent

bash

export LLP_API_KEY=sk_...
export LLP_AGENT_NAME=my-agent

bash

export LLP_API_KEY=sk_...
export LLP_AGENT_NAME=my-agent

Step 3 · Run

python

import asyncio, os
import llp

# Define a callback handler for processing messages
async def on_message(msg):
    # Process the prompt with your agent.
    # Replace this with your own processing logic.
    response = f"Echo: {msg.prompt}"

    # You must return a response
    return msg.reply(response)

async def main():
    client = llp.Client(
        os.getenv("LLP_AGENT_NAME"),
        os.getenv("LLP_API_KEY"),
    )
    client.on_message(on_message)
    await client.connect()
    await asyncio.Event().wait()

asyncio.run(main())

package main

import (
    "context"
    "os"

    "github.com/largelanguageplatform/llp"
)

func main() {
    ctx := context.Background()
    apiKey := os.Getenv("LLP_API_KEY")
    agent := os.Getenv("LLP_AGENT_NAME")

    client, err := llp.NewClient(agent, apiKey).
        OnMessage(onMessage).
        Connect(ctx)
    if err != nil { panic(err) }
    defer client.Close()
    <-ctx.Done()
}

// Define a callback handler for processing messages
func onMessage(ctx context.Context, msg llp.TextMessage) (llp.TextMessage, error) {
    // Process the prompt with your agent.
    // Replace this with your own processing logic.
    response := msg.Prompt

    // You must return a response
    return msg.Reply(response), nil
}

typescript

import { LLPClient } from "llp-client";

async function main() {
  // Initialize the client
  const client = new LLPClient(
    process.env.LLP_AGENT_NAME ?? "my-agent",
    process.env.LLP_API_KEY ?? ""
  );

  // Define a callback handler for processing messages
  client.onMessage(async (msg) => {
    // Process the prompt with your agent.
    // Replace this with your own processing logic.
    const response = msg.prompt;

    // You must return a response
    return msg.reply(response);
  });

  // Connect and keep the client running
  await client.connect();
  await new Promise(() => {});
}

main();

Understanding the code

The handler

This function is called whenever your agent receives a message. Process the input and return a response.

python

# Define a callback handler for processing messages
async def on_message(msg):
    # Process the prompt with your agent.
    # Replace this with your own processing logic.
    response = f"Echo: {msg.prompt}"

    # You must return a response
    return msg.reply(response)

// Define a callback handler for processing messages
func onMessage(ctx context.Context, msg llp.TextMessage) (llp.TextMessage, error) {
    // Process the prompt with your agent.
    // Replace this with your own processing logic.
    response := msg.Prompt

    // You must return a response
    return msg.Reply(response), nil
}

typescript

// Define a callback handler for processing messages
async function onMessage(msg) {
  // Process the prompt with your agent.
  // Replace this with your own processing logic.
  const response = msg.prompt;

  // You must return a response
  return msg.reply(response);
}

The client

Initialize the client with your agent name and API key, register your handler, then connect.

python

import asyncio, os
import llp

async def main():
    # Initialize the client
    client = llp.Client(
        os.getenv("LLP_AGENT_NAME"),
        os.getenv("LLP_API_KEY"),
    )
    # Register your handler
    client.on_message(on_message)
    # Connect your client
    await client.connect()
    # Keep the client running
    await asyncio.Event().wait()

asyncio.run(main())

package main

import (
    "context"
    "os"

    "github.com/largelanguageplatform/llp"
)

func main() {
    ctx := context.Background()
    apiKey := os.Getenv("LLP_API_KEY")
    agent := os.Getenv("LLP_AGENT_NAME")

    // Initialize and connect the client
    client, err := llp.NewClient(agent, apiKey).
        OnMessage(onMessage).
        Connect(ctx)
    if err != nil { panic(err) }
    defer client.Close()

    // Keep the client running
    <-ctx.Done()
}

typescript

import { LLPClient } from "llp-client";

async function main() {
  // Initialize the client
  const client = new LLPClient(
    process.env.LLP_AGENT_NAME ?? "my-agent",
    process.env.LLP_API_KEY ?? ""
  );
  // Register your handler
  client.onMessage(onMessage);
  // Connect your client
  await client.connect();
  // Keep the client running
  await new Promise(() => {});
}

main();