CtrlK

Community Documentation Log in Get started

tessl/maven-com-embabel-agent--embabel-agent-common

Common AI framework utilities for the Embabel Agent system including LLM configuration, output converters, prompt contributors, and embedding service abstractions.

Overview

Eval results

Files

Quick Reference

Name: tessl/maven-com-embabel-agent--embabel-agent-common
Author: tessl

Task-oriented lookup for common operations.

I need to...

Configure an LLM

Use a specific model:

val options = LlmOptions.withModel("gpt-4")

→ Model Configuration

Set temperature and parameters:

val options = LlmOptions.withModel("gpt-4")
    .withTemperature(0.7)
    .withMaxTokens(1000)

→ Hyperparameters

Use fallback models:

val options = LlmOptions.withFirstAvailableLlmOf("gpt-4", "claude-3-opus")

→ Model Selection Strategies

Parse LLM Output

Convert JSON response to typed object:

val converter = JacksonOutputConverter(Person::class.java, objectMapper)
val person = converter.convert(llmResponse)

→ Output Converters

Get JSON schema for prompt:

val schema = converter.jsonSchema

→ Schema Generation

Handle markdown code blocks:

// Automatically handled by converter
val person = converter.convert("""```json
{"name": "Alice"}
```""")

→ Lenient Parsing

Filter properties from schema:

val converter = FilteringJacksonOutputConverter(
    User::class.java,
    objectMapper,
    Predicate { !it.startsWith("internal") }
)

→ Property Filtering

Stream LLM Responses

Process JSONL stream:

val converter = StreamingJacksonOutputConverter(Event::class.java, objectMapper)
val stream: Flux<Event> = converter.convertStream(jsonlResponse)

→ Streaming

Extract thinking blocks:

val stream: Flux<StreamingEvent<Event>> =
    converter.convertStreamWithThinking(response)

→ Thinking Extraction

Calculate Costs

Create pricing model:

val pricing = PricingModel.usdPer1MTokens(30.0, 60.0) // GPT-4

→ Pricing Models

Calculate request cost:

val cost = pricing.costOf(inputTokens = 1000, outputTokens = 500)

→ Cost Calculation

Track session costs:

val tracker = CostTracker(pricing)
tracker.recordUsage(1000, 500)
val total = tracker.totalCost()

→ Cost Tracking

Work with Embeddings

Embed single text:

val embedding: FloatArray = embeddingService.embed(text)

→ Embedding Services

Batch embed texts:

val embeddings: List<FloatArray> = embeddingService.embed(texts)

→ Batch Embedding

Calculate similarity:

val similarity = cosineSimilarity(embedding1, embedding2)

→ Vector Operations

Build Dynamic Prompts

Add fixed content:

val contributor = PromptContributor.fixed(
    "You are a helpful assistant.",
    role = "system",
    location = PromptContributionLocation.BEGINNING
)

→ Prompt Contributors

Add dynamic content:

val contributor = PromptContributor.dynamic(
    { "Current time: ${LocalDateTime.now()}" },
    role = "timestamp"
)

→ Dynamic Contributors

Add current date:

val contributor = CurrentDate()

→ Built-in Contributors

Load Model Configurations

Implement YAML loader:

class MyProviderLoader : AbstractYamlModelLoader<MyProvider>(
    configPath = "META-INF/ai-models/my-provider.yaml"
) {
    override fun getProviderClass() = MyProvider::class
    override fun createEmptyProvider() = MyProvider(emptyList())
    override fun getProviderName() = "my-provider"
    override fun validateModels(provider: MyProvider) { /* ... */ }
}

→ Auto-Configuration

Handle Errors

Check for parsing failure:

val result = converter.convert(llmResponse)
if (result == null) {
    // Handle parsing error
}

→ Error Handling

Catch model selection failure:

try {
    val model = selectModel(criteria, availableModels)
} catch (e: NoSuitableModelException) {
    // Handle no model found
}

→ Exception Types

Common Patterns

LLM request with structured output:

val options = LlmOptions.withModel("gpt-4").withTemperature(0.7)
val converter = JacksonOutputConverter(Response::class.java, objectMapper)
val prompt = "Extract data as: ${converter.jsonSchema}"
val response = llmClient.call(prompt, options)
val parsed = converter.convert(response)

→ Integration Patterns

Streaming with cost tracking:

val converter = StreamingJacksonOutputConverter(Event::class.java, objectMapper)
val tracker = CostTracker(pricing)
val stream = converter.convertStream(jsonlResponse)
stream.doOnComplete { tracker.recordUsage(inputTokens, outputTokens) }

→ Integration Patterns

tessl i tessl/maven-com-embabel-agent--embabel-agent-common@0.3.1

docs

advanced

core

reference

supporting