Polar Llama

from polar_llama.local import make_local_inference_fn
from polar_llama import Predict, Signature, InstructionOptimizer

# Backs Predict/BootstrapFewShot/InstructionOptimizer with on-device gemma-3n
# (mlx-lm). Requires the [local] extra.
fn = make_local_inference_fn("mlx-community/gemma-3n-E4B-it-lm-4bit")
module = Predict(Signature("note -> category", instructions="Classify the note."), inference_fn=fn)

def exact_match(example, prediction):
    return example["category"] == prediction["category"]

compiled = InstructionOptimizer(metric=exact_match).compile(module, trainset)

POLAR_LLAMA_LOCAL_COLLAPSE=1 python tag_column.py

from polar_llama.local import make_local_inference_fn
from polar_llama import Predict, Signature, InstructionOptimizer

# Backs Predict/BootstrapFewShot/InstructionOptimizer with on-device gemma-3n
# (mlx-lm). Collapsed prefill (on by default) shares the system+demos prefix
# across rows — the dominant speedup during tuning, where few-shot demos make
# that prefix ~80% of every prompt (~2.8x on a full tuning schedule, at
# identical output). Requires the [local] extra.
fn = make_local_inference_fn("mlx-community/gemma-3n-E4B-it-lm-4bit")
module = Predict(Signature("note -> category", instructions="Classify the note."), inference_fn=fn)

def exact_match(example, prediction):
    return example["category"] == prediction["category"]

compiled = InstructionOptimizer(metric=exact_match).compile(module, trainset)

import json
import dotenv
import polars as pl
from pydantic import BaseModel

from polar_llama import (
    Provider,
    combine_messages,
    execute_tool_calls,
    inference_messages,
    tool_results_to_message,
    tools_to_response_model,
)

dotenv.load_dotenv()

TOOLS = [
    {
        "name": "search_food_db",
        "description": "Search a nutrition database for one food item and portion.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "The food item, singular"},
                "portion": {"type": "string", "description": "Portion as stated, e.g. 'two eggs'"},
            },
            "required": ["query", "portion"],
        },
    }
]

FAKE_DB = {
    "egg": 78, "sourdough toast": 120, "butter": 102, "black coffee": 2,
    "chicken bowl": 510, "guacamole": 230, "rice": 200,
}

def nutrition_executor(tool_name: str, arguments: dict):
    query = arguments["query"].lower()
    for food, calories in FAKE_DB.items():
        if food in query or query in food:
            return json.dumps({"food": food, "calories_per_serving": calories,
                               "portion": arguments["portion"]})
    return json.dumps({"food": query, "error": "not found"}), True

class NutritionSummary(BaseModel):
    total_calories: int
    items: list[str]
    notes: str

meals = pl.DataFrame({"meal": [
    "two eggs, sourdough toast with butter, black coffee",
    "chipotle chicken bowl, no rice, extra guac",
]})

FoodSearches = tools_to_response_model(TOOLS)

result = (
    meals
    # Turn 1a: the LLM parameterizes N searches per row (structured output).
    .with_columns(
        calls=pl.col("meal").llama.inference_async(
            provider=Provider.OPENAI, model="gpt-4o-mini",
            response_model=FoodSearches,
        )
    )
    # Turn 1b: all searches across all rows execute concurrently.
    .with_columns(
        results=execute_tool_calls(pl.col("calls"), executor=nutrition_executor, tools=TOOLS)
    )
    # Turn 2: reconcile results into a typed summary.
    .with_columns(
        nutrition=inference_messages(
            combine_messages(
                pl.col("meal").llama.to_message(role="user"),
                tool_results_to_message(pl.col("results")),
            ),
            provider=Provider.OPENAI, model="gpt-4o-mini",
            response_model=NutritionSummary,
        )
    )
)

print(result.select("meal", "nutrition"))

import polars as pl
import polar_llama  # registers the .llama namespace

df = pl.DataFrame({"ticket": [
    "My laptop won't turn on even when it's plugged in.",
    "I forgot my password and I'm locked out of my account.",
]})

tagged = df.with_columns(
    tag=pl.col("ticket").llama.inference_local(
        model="mlx-community/gemma-3n-E4B-it-lm-4bit",
        system="Classify the ticket as exactly one of: Hardware, Account, Billing.",
        engine="in_process",   # on-device mlx-lm, batched over the column
        max_tokens=16,
        temperature=0.0,
    )
)

import polars as pl
from polar_llama import Provider

feedback_df = pl.DataFrame({
    'customer_id': [101, 102, 103, 104, 105],
    'feedback': [
        'The product is amazing but shipping was slow',
        'Great quality, highly recommend!',
        'Disappointed with customer service',
        'Perfect for my needs, will buy again',
        'Product arrived damaged, requesting refund'
    ]
})

sentiment_prompt = """Analyze the sentiment of this customer feedback
and classify it as Positive, Negative, or Neutral.
Also provide a brief reason.

Feedback: {feedback}"""

df = feedback_df.with_columns(
    prompt=pl.format(sentiment_prompt, pl.col('feedback'))
)

df = df.with_columns(
    sentiment_analysis=pl.col('prompt').llama.inference_async(
        provider=Provider.OPENAI,
        model='gpt-4o-mini'
    )
)

print(df.select(['customer_id', 'feedback', 'sentiment_analysis']))