One API for
All LLMs.
Zero Lock-In.

# Install PlugLLM from PyPI
pip install plugllm

# Optional: with dev dependencies
pip install "plugllm[dev]"

# Set your API keys
export OPENAI_API_KEY="sk-..."
export GEMINI_API_KEY="AIza..."
export GROQ_API_KEY="gsk_..."
export ANTHROPIC_API_KEY="sk-ant-..."

from plugllm import ChatOpenAI, ChatGroq, LLMFactory

# .generate() — simple text completion
llm = ChatOpenAI(model="gpt-4o")
text = llm.generate("What is the difference between AI and ML?")

# .ask() — Q&A with optional system prompt
answer = llm.ask(
    "Explain transformers architecture",
    system_prompt="You are a senior ML engineer. Be concise.",
    max_tokens=300
)
print(answer.content)   # ChatResponse object
print(answer.model)     # "gpt-4o"

# LLMFactory — dynamic provider switching
llm2 = LLMFactory.create("gemini", model="gemini-2.5-flash")
result = llm2.generate("Summarize the Transformer paper")

# Fluent chaining interface
response = (
    ChatGroq()
    .with_system("You are a Python expert.")
    .with_temperature(0.2)
    .call("Write a binary search function")
)

from plugllm import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", max_history=20)

# Multi-user session isolation
llm.chat("My name is Alice, I live in Paris", session_id="alice")
llm.chat("My favourite language is Python",   session_id="alice")
llm.chat("I'm Bob, a data scientist in Tokyo", session_id="bob")

# Each session has completely isolated memory
print(llm.chat("Where do I live?",    session_id="alice"))
# → "You live in Paris."

print(llm.chat("What do I work with?", session_id="bob"))
# → "You mostly work with PyTorch."

# Clear memory for a session
llm.clear_history(session_id="alice")
history = llm.get_history(session_id="bob")

from plugllm import ChatGroq

llm = ChatGroq(model="llama-3.3-70b-versatile")

# Synchronous streaming
for chunk in llm.stream("Write a short poem about Python"):
    print(chunk, end="", flush=True)

# Stream with system prompt
for chunk in llm.stream(
    "Explain async/await in Python",
    system_prompt="You are a concise technical writer."
):
    print(chunk, end="", flush=True)

import asyncio
from plugllm import ChatGemini, ChatGroq, ChatOpenAI

async def parallel_summarize(text: str) -> dict:
    providers = {
        "GPT-4o":  ChatOpenAI(model="gpt-4o-mini"),
        "Gemini":  ChatGemini(model="gemini-2.5-flash"),
        "Llama":   ChatGroq(model="llama-3.3-70b-versatile"),
    }
    prompt = f"Summarize in 2 sentences:\n{text}"
    tasks = {name: llm.agenerate(prompt) for name, llm in providers.items()}
    results = await asyncio.gather(*tasks.values())
    return dict(zip(tasks.keys(), results))

async def main():
    summaries = await parallel_summarize(
        "Transformer architecture uses self-attention..."
    )
    for provider, summary in summaries.items():
        print(f"\n[{provider}]\n{summary}")

asyncio.run(main())