WizardAI SDK

# Option 1: Pass directly
wiz = wizardai.WizardAI(api_key="YOUR_API_KEY")

# Option 2: Environment variable (recommended)
# CMD: set WIZARDAI_API_KEY=your_key_here
# PS:  $env:WIZARDAI_API_KEY = "your_key_here"
wiz = wizardai.WizardAI()  # picks up env var automatically

# Option 3: Set at runtime
wiz.set_api_key("YOUR_API_KEY")

import wizardai

# ── 1. Create and start a session ──────────────────────────
wiz = wizardai.WizardAI(api_key="YOUR_API_KEY")
wiz.start()

# ── 2. Direct LLM call ─────────────────────────────────────
print(wiz.ask("What is the speed of light?"))

# ── 3. Add a pattern rule (no API call) ────────────────────
wiz.agent.add_pattern("hello", "Hello from WizardAI!")
print(wiz.chat("hello"))

# ── 4. Streaming response ───────────────────────────────────
for chunk in wiz.ai.chat_stream([{"role":"user","content":"Write a haiku"}]):
    print(chunk, end="", flush=True)

# ── 5. Long-term memory ─────────────────────────────────────
wiz.remember("user_name", "Alice")
print(wiz.recall("user_name"))  # → Alice

# ── 6. Stop session ─────────────────────────────────────────
wiz.stop()

# ── Or use as a context manager ─────────────────────────────
with wizardai.WizardAI(api_key="YOUR_API_KEY") as wiz:
    print(wiz.ask("Hello!"))

from wizardai import AIClient

client = AIClient(api_key="YOUR_KEY")

# Non-streaming
resp = client.complete("Explain quantum entanglement simply.")
print(resp.text)
print(f"Tokens used: {resp.usage}")
print(f"Latency: {resp.latency_ms:.0f}ms")

# Streaming
for chunk in client.complete_stream("Tell me a story"):
    print(chunk, end="", flush=True)

# Multi-turn chat
messages = [
    {"role": "user",      "content": "My name is Alice."},
    {"role": "assistant", "content": "Nice to meet you, Alice!"},
    {"role": "user",      "content": "What's my name?"},
]
resp = client.chat(messages, system_prompt="You are a friendly assistant.")
print(resp.text)  # → Your name is Alice.

from wizardai import ConversationAgent

agent = ConversationAgent(name="MyBot")

# Static response
agent.add_pattern("hello", "Hello! How can I help?")

# Wildcard — {wildcard} contains captured text
agent.add_pattern("my name is *", "Nice to meet you, {wildcard}!")

# Named capture group
agent.add_pattern("call me {name}", "Sure, I'll call you {name}.")

# Random alternatives
agent.add_pattern("how are you", ["I'm great!", "Ready to help!", "All good!"])

# Callable template
import datetime
agent.add_pattern("what time is it", lambda: f"It is {datetime.datetime.now():%H:%M}.")

# Priority — matched before lower-priority rules
agent.add_pattern("hello *", "Hey {wildcard}!", priority=10)

# Inline plugin (!calc expression)
agent.register_plugin("calc", lambda args: eval(args))

print(agent.respond("hello"))
print(agent.respond("!calc 3 * 7"))  # → 21

from wizardai import PluginBase, PluginManager
import random

class JokePlugin(PluginBase):
    name        = "jokes"
    description = "Tells jokes on demand."
    version     = "1.0.0"
    author      = "WizardAI Dev"
    triggers    = ["joke", "tell me a joke", "make me laugh"]

    def setup(self):
        self.jokes = [
            "Why do Python devs wear glasses? They can't C!",
            "What's a computer's favourite snack? Microchips.",
            "Why was the web developer stressed? Too many tabs.",
        ]

    def on_message(self, text, context):
        text_lower = text.lower()
        if any(kw in text_lower for kw in self.triggers):
            return random.choice(self.jokes)
        return None  # pass to next plugin

# Register and use
manager = PluginManager()
manager.register(JokePlugin)

print(manager.dispatch("tell me a joke"))
print(manager.dispatch("hello there"))  # → None (no match)

from wizardai import VisionModule

# Context-manager usage
with VisionModule(device_id=0, width=1280, height=720) as cam:
    frame = cam.capture_frame()
    cam.save_frame(frame, "snapshot.jpg", quality=90)

    # Face detection
    annotated, faces = cam.annotate_faces(frame)
    print(f"Found {len(faces)} face(s)")
    cam.save_frame(annotated, "faces.jpg")

    # Send frame to AI for vision query
    b64 = cam.encode_to_base64(frame)
    # wiz.ask("Describe this image", image_b64=b64)

    # Live stream with callback
    def on_frame(f):
        _, face_list = cam.annotate_faces(f)
        if face_list:
            print("Face detected!")

    cam.start_stream(callback=on_frame, show_preview=True)

from wizardai import WizardAI

wiz = WizardAI(
    api_key="YOUR_KEY",
    enable_speech=True,
    stt_backend="google",
    tts_backend="pyttsx3",
    language="en-US",
)
wiz.start()

# Single voice exchange
response = wiz.voice_chat(timeout=8.0)
print(f"Bot said: {response}")

# Continuous background listener
def handle_speech(text):
    reply = wiz.chat(text)
    wiz.say(reply)

wiz.speech.start_continuous_listening(callback=handle_speech)
# ... your app logic ...
wiz.speech.stop_continuous_listening()
wiz.stop()

log = wizardai.Logger("my_app", level="DEBUG", log_file="app.log")
log.info("Session started")
log.warning("Memory usage high")
log.error("Connection failed")
log.set_level("WARNING")

limiter = wizardai.RateLimiter(max_calls=10, period=60)

for item in large_list:
    limiter.wait()  # blocks if needed
    process(item)

# Context-manager style
with limiter:
    api_call()

from wizardai import WizardAI, AuthenticationError, RateLimitError, APIError

try:
    response = wiz.ask("Hello")
except AuthenticationError as e:
    print(f"Auth failed: {e.message}")
    print("→ Visit https://sagittarius-labs.pages.dev/ for a key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after}s")
except APIError as e:
    print(f"API error {e.code}: {e.message}")
except Exception as e:
    print(f"Unexpected: {e}")

import wizardai

wiz = wizardai.WizardAI(
    api_key="YOUR_KEY",
    agent_name="Sage",
    system_prompt="You are Sage, a wise and helpful AI assistant.",
    memory_path="./session_memory.json",
    log_level="WARNING",
)
wiz.start()
wiz.run_repl(prompt_str="You: ", quit_commands=["quit", "/q", "exit"])

import wizardai

with wizardai.WizardAI(api_key="YOUR_KEY", enable_vision=True) as wiz:
    frame = wiz.capture()
    b64   = wiz.vision.encode_to_base64(frame)
    answer = wiz.ask("Describe what you see in this image.", image_b64=b64)
    print(answer)
    wiz.snapshot("./captured.jpg")

import wizardai

wiz = wizardai.WizardAI(api_key="YOUR_KEY", memory_path="./memory.json")
wiz.start()

# Store facts
wiz.remember("user_name", "Alice")
wiz.remember("user_city", "London")
wiz.remember("preferences", {"lang": "en", "theme": "dark"})

# Recall later
name = wiz.recall("user_name")  # → 'Alice'
wiz.agent.add_pattern(
    "what is my name",
    f"Your name is {memory:user_name}.",
)
print(wiz.chat("what is my name"))  # → Your name is Alice.

# Search history
results = wiz.memory.search_history("name", top_k=3)
for msg, score in results:
    print(f"[{score:.2f}] {msg.role}: {msg.content[:50]}")

wiz.stop()

import wizardai
import datetime

class TimePlugin(wizardai.PluginBase):
    name        = "time"
    description = "Returns current time and date."
    version     = "1.0.0"
    triggers    = ["time", "date", "what time"]

    def on_message(self, text, context):
        text_l = text.lower()
        if "time" in text_l or "date" in text_l:
            now = datetime.datetime.now()
            return f"It is {now:%A, %B %d %Y} at {now:%H:%M:%S}."
        return None

class WeatherPlugin(wizardai.PluginBase):
    name        = "weather"
    description = "Stub weather plugin."
    version     = "1.0.0"

    def on_message(self, text, context):
        if "weather" in text.lower():
            return "It's sunny and 22°C. Perfect for coding!"
        return None

with wizardai.WizardAI(api_key="YOUR_KEY") as wiz:
    wiz.add_plugin(TimePlugin)
    wiz.add_plugin(WeatherPlugin)

    print(wiz.chat("what time is it"))     # → TimePlugin
    print(wiz.chat("what's the weather"))    # → WeatherPlugin
    print(wiz.chat("explain relativity"))    # → LLM fallback

from wizardai import FileHelper, DataSerializer

fh = FileHelper(base_dir="./data")
ds = DataSerializer()

# Write and read text
fh.write_text("notes.txt", "WizardAI is awesome!")
print(fh.read_text("notes.txt"))

# Write and read JSON
fh.write_json("config.json", {"model": "deep-vl", "temp": 0.7})
cfg = fh.read_json("config.json")

# CSV round-trip
rows = [{"name": "Alice", "score": 95}, {"name": "Bob", "score": 87}]
fh.write_csv("scores.csv", rows)
print(fh.read_csv("scores.csv"))

# Compressed pickle
ds.save({"big": "data"}, "./cache.pkl.gz")
data = ds.load("./cache.pkl.gz")

# JSON-Lines
ds.write_jsonl("./records.jsonl", [{"id": 1}, {"id": 2}])
for rec in ds.iter_jsonl("./records.jsonl"):
    print(rec)