prompt-executor-mistralai-client

val mistralParams = MistralAIParams(
    temperature = 0.7,
    maxTokens = 1000,
    topP = 0.9,
    frequencyPenalty = 0.5,
    presencePenalty = 0.5,
    stop = listOf("\n", "END"),
    randomSeed = 42,
    parallelToolCalls = true,
    safePrompt = false,
    promptMode = "reasoning"
)

dependencies {
    implementation("ai.koog.prompt:prompt-executor-mistralai-client:$version")
}

val mistralClient = MistralAILLMClient(
    apiKey = "your-mistral-api-key",
)

suspend fun main() {
    val client = MistralAILLMClient(
        apiKey = System.getenv("MISTRAL_API_KEY"),
    )

    // Basic example
    val response = client.execute(
        prompt = prompt {
            system("You are helpful assistant")
            user("What time is it now?")
        },
        model = MistralAIModels.Chat.MistralMedium31,
    )

    // Advanced example with custom parameters
    val advancedResponse = client.execute(
        prompt = prompt {
            system("You are a helpful coding assistant")
            user("Write a Python function to calculate factorial")
        },
        model = MistralAIModels.Chat.Codestral,
        params = MistralAIParams(
            temperature = 0.3,
            maxTokens = 2000,
            frequencyPenalty = 0.1,
            topP = 0.95,
            stop = listOf("```\n\n"),
            randomSeed = 42
        )
    )

    println(response)
    println(advancedResponse)
}

// Vision: Image analysis with MistralMedium31
val imageResponse = client.execute(
    prompt = prompt {
        user {
            text("What do you see in this image?")
            image("/path/to/image.jpg")
        }
    },
    model = MistralAIModels.Chat.MistralMedium31,
    params = MistralAIParams(
        temperature = 0.3,
        maxTokens = 1000
    )
)

// Document processing with MagistralMedium12
val documentResponse = client.execute(
    prompt = prompt {
        user {
            text("Summarize this document")
            document("/path/to/document.pdf")
        }
    },
    model = MistralAIModels.Chat.MagistralMedium12,
    params = MistralAIParams(
        temperature = 0.5,
        maxTokens = 2000,
        promptMode = "reasoning"
    )
)

// Mixed content with vision model
val mixedResponse = client.execute(
    prompt = prompt {
        user {
            text("Compare this image with the document:")
            image("/path/to/chart.png")
            document("/path/to/report.pdf")
            text("What are the key differences?")
        }
    },
    model = MistralAIModels.Chat.MagistralMedium12,
    params = MistralAIParams(
        temperature = 0.5,
        maxTokens = 4000
    )
)

// Structured output with JSON schema
val structuredResponse = client.execute(
    prompt = prompt {
        system("Extract key information as JSON")
        user("John Doe, age 30, works as software engineer at TechCorp")
    },
    model = MistralAIModels.Chat.MistralMedium31,
    params = MistralAIParams(
        temperature = 0.1,
        schema = jsonSchema {
            object {
                property("name", string())
                property("age", integer())
                property("occupation", string())
                property("company", string())
            }
        }
    )
)

// Multiple choices generation
val choices = client.executeMultipleChoices(
    prompt = prompt {
        system("You are a creative assistant")
        user("Give me three different opening lines for a story")
    }.withUpdatedParams {
        numberOfChoices = 3
        temperature = 0.8
    },
    model = MistralAIModels.Chat.MistralLarge21
)

// Embedding example
val embedding = client.embed(
    text = "This is a sample text for embedding",
    model = MistralAIModels.Embeddings.MistralEmbed
)

// Code embedding
val codeEmbedding = client.embed(
    text = "function factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); }",
    model = MistralAIModels.Embeddings.CodestralEmbed
)

// Moderation example
val moderationResult = client.moderate(
    prompt = prompt {
        user("This is a test message for content safety check")
    },
    model = MistralAIModels.Moderation.MistralModeration
)

if (moderationResult.isHarmful) {
    println("Content flagged as harmful")
    moderationResult.categories.forEach { (category, result) ->
        if (result.detected) {
            println("Category: $category, Score: ${result.confidenceScore}")
        }
    }
}

// Coding with Devstral Medium (enterprise coding model)
val codingResponse = client.execute(
    prompt = prompt {
        system("You are an expert software engineer")
        user("Refactor this code to use async/await pattern:\n\n$codeSnippet")
    },
    model = MistralAIModels.Chat.DevstralMedium,
    params = MistralAIParams(
        temperature = 0.2,
        maxTokens = 3000
    )
)

// Edge deployment with Ministral 3B
val edgeResponse = client.execute(
    prompt = prompt {
        system("You are a helpful assistant")
        user("What is the capital of France?")
    },
    model = MistralAIModels.Chat.Ministral3B,
    params = MistralAIParams(
        temperature = 0.5,
        maxTokens = 100
    )
)

// Reasoning with MagistralMedium12
val reasoningResponse = client.execute(
    prompt = prompt {
        system("Solve this step by step")
        user("If a train travels 120 km in 2 hours, what's its average speed?")
    },
    model = MistralAIModels.Chat.MagistralMedium12,
    params = MistralAIParams(
        temperature = 0.5,
        promptMode = "reasoning"
    )
)

// Streaming example
client.executeStreaming(
    prompt = prompt {
        user("Write a short story about AI")
    },
    model = MistralAIModels.Chat.MistralLarge21
).collect { chunk ->
    print(chunk)
}