Build on AI capabilities.
Write once, run on any model.

from abstractcore import create_llm

llm = create_llm("openai", model="gpt-4o-mini")

# Hear: a recording in, its transcript out
heard = llm.generate(media={"type": "audio", "path": "meeting.wav"},
                     output="text")
text = llm.audio.transcribe("speech.wav")

# Speak: text in, audio out
speech = llm.generate(text="Hello from AbstractCore.", output="voice")
wav_bytes = speech.outputs["voice"][0].data

# Voices by language, or design your own from a description
french = llm.voice.list_voices(language="fr")
mira = llm.voice.design_voice("A calm, warm female voice in her thirties.",
                              name="Mira")
wav = llm.voice.tts("Good morning.", voice=mira["voice_id"], one_shot=True)

# Image generation via AbstractVision
image = llm.generate("A red ceramic mug on a white table.", output="image")
png_bytes = image.outputs["image"][0].data

# Image edit: a source image and an optional style reference
edited = llm.generate(
    "Make the mug blue using the second image as a style reference.",
    media=[
        {"type": "image", "path": "mug.png", "role": "source"},
        {"type": "image", "path": "style.png", "role": "style"},
    ],
    output="image",
)

# Image to video: the image is the first frame
clip = llm.generate(
    "Slow camera push-in.",
    media={"type": "image", "path": "first-frame.png", "role": "source"},
    output={"modality": "video", "task": "image_to_video"},
)

# Music via AbstractMusic
music = llm.generate(
    text="A short calm piano loop.",
    output={"modality": "music", "provider": "acemusic",
            "duration_s": 8, "format": "wav"},
)
music_wav = music.outputs["music"][0].data

# A sound effect: the sound output, with its length in seconds
resp = llm.generate(
    text="laser gunshot",
    output={"modality": "sound", "task": "text_to_audio",
            "seconds": 3, "format": "wav"},
)
clip = resp.outputs["sound"][0]

from pydantic import BaseModel
from abstractcore import create_llm

class Answer(BaseModel):
    title: str
    bullets: list[str]

llm = create_llm("openai", model="gpt-4o-mini")
answer = llm.generate("Summarize HTTP/3 in 3 bullets.", response_model=Answer)
print(answer.bullets)

from abstractcore import create_llm, tool

@tool
def get_weather(city: str) -> str:
    """Current weather for a city.

    Args:
        city: The city name, for example "Paris".
    """
    return f"{city}: 22°C and sunny"

llm = create_llm("openai", model="gpt-4o-mini")
resp = llm.generate("What's the weather in Paris? Use the tool.",
                    tools=[get_weather])

print(resp.content)
print(resp.tool_calls)  # your code decides whether to run them

from abstractcore import create_llm, BasicSession

session = BasicSession(create_llm("anthropic", model="claude-haiku-4-5"))
print(session.generate("Give me 3 bakery name ideas.").content)
print(session.generate("Pick the best one and explain why.").content)

llm = create_llm("ollama", model="qwen3:4b")
for chunk in llm.generate("Write a short poem about distributed systems.",
                          stream=True):
    print(chunk.content or "", end="", flush=True)

# One server for every application, in any language
abstractcore serve        # 127.0.0.1:8000; prints a one-time console link
export ABSTRACTCORE_AUTH_TOKEN="$(abstractcore serve --print-token)"

curl -X POST http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ABSTRACTCORE_AUTH_TOKEN" \
  -d '{"model": "openai/gpt-4o-mini",
       "messages": [{"role": "user", "content": "Hello!"}]}'

# Same server: /v1/responses, /v1/embeddings, /v1/images/generations,
# /v1/audio/speech, /v1/audio/transcriptions, /v1/decisions

abstractcore host profile                # accelerator, memory ceiling, free disk
abstractcore models catalog --fits       # downloadable models that fit
abstractcore models download ollama qwen3:8b
abstractcore models list                 # installed models per engine
abstractcore models verify qwen3:8b --provider ollama
abstractcore engines install ollama --dry-run   # the exact install command