AiVerse - AI Knowledge Encyclopedia

from openai import OpenAI
client = OpenAI(api_key="YOUR_KEY", base_url="https://api.deepseek.com")
response = client.chat.completions.create(
  model="deepseek-chat",
  messages=[{"role": "user", "content": "Explain MLA architecture."}]
)

• DeepSeek-V3 Technical Report

from openai import OpenAI
client = OpenAI(api_key="YOUR_KEY", base_url="https://api.deepseek.com")
response = client.chat.completions.create(
  model="deepseek-reasoner",
  messages=[{"role": "user", "content": "Solve: What is the sum of integers from 1 to 100?"}]
)

• DeepSeek-R1 Technical Report

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Qwen-32B", device_map="auto")

• DeepSeek-R1 Distillation

from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-Coder-V2-Instruct", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/DeepSeek-Coder-V2-Instruct", trust_remote_code=True, device_map="auto")

• DeepSeek-Coder-V2 Paper

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.3-70B-Instruct", device_map="auto")

• Llama 3.3 Release

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B-Instruct", device_map="auto")

• Llama 3.2 Announcement

from transformers import MllamaForConditionalGeneration, AutoProcessor
model = MllamaForConditionalGeneration.from_pretrained("meta-llama/Llama-3.2-11B-Vision-Instruct", device_map="auto")

• Llama 3.2 Vision Model Card

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-72B-Instruct", device_map="auto")

• Qwen2.5 Announcement

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-Coder-32B-Instruct", device_map="auto")

• Qwen2.5-Coder Technical Blog

from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
model = Qwen2_5_VLForConditionalGeneration.from_pretrained("Qwen/Qwen2.5-VL-72B-Instruct", device_map="auto")

• Qwen2.5-VL Release

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-Math-72B-Instruct", device_map="auto")

• Qwen2.5-Math Paper

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
  model="claude-3-7-sonnet-20250219",
  max_tokens=4096,
  thinking={"type": "enabled", "budget_tokens": 2048},
  messages=[{"role": "user", "content": "Analyze complex architecture vulnerabilities."}]
)

• Claude 3.7 Sonnet Announcement

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
  model="claude-3-5-haiku-20241022",
  max_tokens=1024,
  messages=[{"role": "user", "content": "Extract entities from this invoice."}]
)

• Claude 3.5 Haiku Release

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="o3-mini",
  reasoning_effort="medium",
  messages=[{"role": "user", "content": "Design an optimal LRU cache in Rust."}]
)

• OpenAI o3-mini Announcement

from google import genai
client = genai.Client()
response = client.models.generate_content(
  model="gemini-2.0-flash",
  contents="Explain quantum computing simply."
)

• Gemini 2.0 Flash Release

from google import genai
client = genai.Client()
response = client.models.generate_content(
  model="gemini-2.0-flash-thinking-exp",
  contents="Solve this physics circuit diagram problem."
)

• Gemini Thinking Model

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("microsoft/phi-4", device_map="auto")

• Phi-4 Technical Report

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3.5-MoE-instruct", trust_remote_code=True, device_map="auto")

• Phi-3.5 Announcement

from mistralai import Mistral
client = Mistral(api_key="API_KEY")
response = client.chat.complete(
  model="mistral-large-latest",
  messages=[{"role": "user", "content": "Analyze economic trends."}]
)

• Mistral Large 2 Announcement

from mistralai import Mistral
client = Mistral(api_key="API_KEY")
response = client.fim.complete(
  model="codestral-latest",
  prompt="def calculate_fibonacci(n):",
  suffix="return result"
)

• Codestral Announcement

import torch
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
image = pipe("A cozy cafe on Mars with neon lighting", num_inference_steps=4).images[0]

• FLUX.1 Release

from diffusers import HunyuanVideoPipeline
pipe = HunyuanVideoPipeline.from_pretrained("Tencent-Hunyuan/HunyuanVideo", torch_dtype=torch.bfloat16)
video = pipe("Astronaut riding a horse on the moon, cinematic 4k").frames[0]

• HunyuanVideo Technical Report

from diffusers import CogVideoXPipeline
pipe = CogVideoXPipeline.from_pretrained("THUDM/CogVideoX-5b", torch_dtype=torch.bfloat16)
video = pipe(prompt="A golden retriever swimming in a crystal clear lake").frames[0]

• CogVideoX Paper

from diffusers import MochiPipeline
pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", torch_dtype=torch.bfloat16)

• Mochi 1 Preview

from diffusers import LTXPipeline
pipe = LTXPipeline.from_pretrained("Lightricks/LTX-Video", torch_dtype=torch.bfloat16)

• LTX-Video Announcement

import whisper
model = whisper.load_model("turbo")
result = model.transcribe("audio.mp3")
print(result["text"])

• Whisper Turbo Release

from kokoro import KPipeline
pipeline = KPipeline(lang_code='a')
generator = pipeline("Hello, welcome to AiVerse!", voice='af_heart', speed=1.0)

• Kokoro Model Card

from langgraph.graph import StateGraph, START, END
builder = StateGraph(dict)
builder.add_node("agent", lambda state: {"msg": "Done"})
builder.add_edge(START, "agent")
builder.add_edge("agent", END)
graph = builder.compile()

• LangGraph Docs

from crewai import Agent, Task, Crew
researcher = Agent(role='Researcher', goal='Investigate tech trends', memory=True)
task = Task(description='Summarize 2025 AI models', expected_output='Bullet summary', agent=researcher)
crew = Crew(agents=[researcher], tasks=[task])
crew.kickoff()

• CrewAI Documentation

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
agent = AssistantAgent("assistant", OpenAIChatCompletionClient(model="gpt-4o"))

• AutoGen v0.4 Architecture

import sglang as sgl
@sgl.function
def qa(s, question):
    s += sgl.user(question)
    s += sgl.assistant(sgl.gen("answer", max_tokens=100))

• SGLang Paper

from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.3-70B-Instruct-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True
)

• Unsloth Documentation

accelerate launch -m axolotl.cli.train config.yaml

• Axolotl Repository

import dspy
dspy.settings.configure(lm=dspy.OpenAI(model='gpt-4o'))
class MultiHopQA(dspy.Module):
    def __init__(self):
        self.generate_query = dspy.ChainOfThought("claim -> query")
        self.retrieve = dspy.Retrieve(k=3)

• DSPy Paper

from smolagents import CodeAgent, HfApiModel, DuckDuckGoSearchTool
agent = CodeAgent(tools=[DuckDuckGoSearchTool()], model=HfApiModel())
agent.run("What is the latest score of the Mars Rover mission?")

• Smolagents Launch

import instructor
from openai import OpenAI
from pydantic import BaseModel

client = instructor.from_openai(OpenAI())
class User(BaseModel):
    name: str
    age: int

user = client.chat.completions.create(
    model="gpt-4o",
    response_model=User,
    messages=[{"role": "user", "content": "Alice is 28 years old."}]
)

• Instructor Docs

import outlines
model = outlines.models.transformers("meta-llama/Llama-3.2-3B")
generator = outlines.generate.json(model, UserSchema)
result = generator("Extract user details from text")

• Outlines Paper

from litellm import completion
response = completion(
    model="anthropic/claude-3-5-sonnet-20240620",
    messages=[{"role": "user", "content": "Hello World"}]
)

• LiteLLM Documentation

import { pipeline } from '@huggingface/transformers';
const classifier = await pipeline('sentiment-analysis');
const output = await classifier('I love running AI locally in my browser!');

• Transformers.js Docs

from distilabel.pipeline import Pipeline
with Pipeline("SyntheticData") as pipeline:
    # Define generation steps and LLM judges

• Distilabel Docs

fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "model": "deepseek/deepseek-r1",
    "messages": [{"role": "user", "content": "Hello!"}]
  })
})

• OpenRouter

from groq import Groq
client = Groq(api_key="GROQ_API_KEY")
response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",
    messages=[{"role": "user", "content": "Summarize this live."}]
)

• Groq LPU Architecture

import modal
app = modal.App("fast-inference")
@app.function(gpu="A100")
def generate():
    return "Generated from serverless GPU"

• Modal Documentation

from openai import OpenAI
client = OpenAI(base_url="https://api.fireworks.ai/inference/v1", api_key="FW_KEY")
response = client.chat.completions.create(model="accounts/fireworks/models/deepseek-v3", messages=[...])

• Fireworks AI Platform

from cerebras.cloud.sdk import Cerebras
client = Cerebras(api_key="CEREBRAS_API_KEY")
response = client.chat.completions.create(model="llama3.1-70b", messages=[{"role": "user", "content": "Fast code review."}])

• Cerebras Inference

./llama-cli -m models/llama-3.3-70b-instruct.Q4_K_M.gguf -p "Explain gravity" -n 128

• llama.cpp GitHub

import runpod
runpod.api_key = "KEY"
endpoint = runpod.Endpoint("ENDPOINT_ID")
run_request = endpoint.run({"input": {"prompt": "AI art"}})
print(run_request.output())

• RunPod Docs

import openai
client = openai.OpenAI(api_key="DEEPINFRA_KEY", base_url="https://api.deepinfra.com/v1/openai")
res = client.chat.completions.create(model="meta-llama/Llama-3.3-70B-Instruct", messages=[...])

• DeepInfra

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="your-api-key"
# All LangChain & LangGraph calls automatically trace to dashboard

• LangSmith Documentation

import weave
weave.init('my-ai-app')
@weave.op()
def generate_response(prompt: str) -> str:
    # Automatically tracked in dashboard
    return "Response"

• Weave Docs

from openai import OpenAI
client = OpenAI(base_url="https://oai.helicone.ai/v1", default_headers={"Helicone-Auth": "Bearer HELICONE_API_KEY"})

• Helicone Documentation

from portkey_ai import Portkey
portkey = Portkey(api_key="PORTKEY_API_KEY")
response = portkey.chat.completions.create(model="gpt-4o", messages=[{"role": "user", "content": "Hello!"}])

• Portkey Docs

from datasets import load_dataset
ds = load_dataset("HuggingFaceFW/fineweb-edu", name="sample-100BT", split="train", streaming=True)

• FineWeb Announcement

from datasets import load_dataset
ds = load_dataset("HuggingFaceTB/cosmopedia", split="train", streaming=True)

• Cosmopedia Blog

from datasets import load_dataset
ds = load_dataset("HuggingFaceH4/ultrafeedback_binarized", split="train_prefs")

• UltraFeedback Paper

from datasets import load_dataset
ds = load_dataset("teknium/OpenHermes-2.5", split="train")

• OpenHermes 2.5 Dataset

from datasets import load_dataset
ds = load_dataset("HuggingFaceH4/MATH-500", split="test")

• MATH Benchmark Paper

from datasets import load_dataset
ds = load_dataset("princeton-nlp/SWE-bench_Verified", split="test")

• SWE-bench Verified

from datasets import load_dataset
ds = load_dataset("livecodebench/code_generation_lite", split="test")

• LiveCodeBench Paper

from datasets import load_dataset
ds = load_dataset("gaia-benchmark/GAIA", "2023_all", split="validation")

• GAIA Benchmark Paper

from datasets import load_dataset
ds = load_dataset("lmsys/chatbot_arena_conversations", split="train")

• LMSYS Chatbot Arena Paper

from datasets import load_dataset
ds = load_dataset("allenai/dolma", split="train", streaming=True)

• Dolma Technical Paper

from datasets import load_dataset
ds = load_dataset("allenai/WildChat-1M", split="train")

• WildChat Paper

python -m arena_hard.eval --model-answers answers.jsonl

• Arena-Hard-Auto Release

Visit v0.dev, enter prompt: "Modern crypto portfolio dashboard with dark mode charts", and click Copy Code to paste into your Next.js project.

• v0 by Vercel

Go to lovable.dev, type your app idea (e.g. "Airbnb for pet boarding"), customize components interactively, and deploy live.

• Lovable.dev

Upload research papers, meeting notes, or PDFs at notebooklm.google.com, then click 'Audio Overview' to generate an engaging AI podcast explanation.

• NotebookLM

Assign a GitHub issue or feature ticket to Devin via the Cognition dashboard or Slack integration.

• Devin Announcement

docker run -it --pull=always -e SANDBOX_USER_ID=$(id -u) -v /var/run/docker.sock:/var/run/docker.sock -p 3000:3000 ghcr.io/all-hands-ai/openhands:latest

• OpenHands Repository

Launch Granola on Mac during a Zoom or Google Meet call, take quick notes, and click enhance.

• Granola

Press global hotkey, speak naturally, and your voice is instantly transcribed and punctuated into the active cursor.

• Superwhisper

Visit phind.com and query "How to configure SSL in NGINX reverse proxy with Certbot in Docker".

• Phind

Open krea.ai, draw shapes on the left canvas, and see photorealistic 4k renders update live on the right.

• Krea AI

Ask Glean: "What is the status of project Orion and who is leading the security audit?"

• Glean Enterprise Search

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="gpt-4o",
  messages=[{"role": "user", "content": "Hello!"}]
)

• GPT-4o Announcement

import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
  model="claude-3-5-sonnet-20240620",
  max_tokens=1000,
  messages=[{"role": "user", "content": "Write a React component."}]
)

• Claude 3.5 Sonnet Release

import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
  model="claude-3-opus-20240229",
  max_tokens=2048,
  messages=[{"role": "user", "content": "Analyze this research paper."}]
)

• Claude 3 Model Card

import google.generativeai as genai
genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-1.5-pro')
response = model.generate_content("Summarize this 1000-page PDF.")

• Gemini 1.5 Pro Technical Paper

import google.generativeai as genai
genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-1.5-flash')
response = model.generate_content("Summarize this article quickly.")

• Gemini 1.5 Flash Announcement

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-70B-Instruct")
model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-70B-Instruct")

• Introducing Meta Llama 3

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")
model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")

• Introducing Meta Llama 3

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

• Mistral 7B Paper

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")

• Mixtral of Experts Paper

from mistralai.client import MistralClient
client = MistralClient(api_key="YOUR_API_KEY")
response = client.chat(
  model="mistral-large-latest",
  messages=[{"role": "user", "content": "Explain quantum entanglement."}]
)

• Mistral Large Announcement

import cohere
co = cohere.Client("YOUR_API_KEY")
response = co.chat(
  model="command-r-plus",
  message="What are the latest trends in AI?",
  documents=[{"text": "...your documents here..."}]
)

• Command R+ Announcement

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("microsoft/Phi-3-mini-4k-instruct")
tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-4k-instruct")

• Phi-3 Technical Report

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-72B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-72B-Instruct")

• Qwen2 Technical Report

from transformers import AutoModelForCausalLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2")
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/DeepSeek-V2", trust_remote_code=True)

• DeepSeek-V2 Paper

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="o1-preview",
  messages=[{"role": "user", "content": "Solve this complex math proof."}]
)

• OpenAI o1 System Card

# Grok-1 weights available on HuggingFace
# Run locally with sufficient GPU cluster
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("xai-org/grok-1")

• Grok-1 Release

from transformers import pipeline
pipe = pipeline("text-generation", model="meta-llama/Meta-Llama-3.1-405B-Instruct")
pipe("Hello world!")

• Llama 3.1 Announcement

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="gpt-4o-mini",
  messages=[{"role": "user", "content": "Hello!"}]
)

• GPT-4o mini Announcement

import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
  model="claude-3-haiku-20240307",
  max_tokens=1000,
  messages=[{"role": "user", "content": "Summarize this quickly."}]
)

• Claude 3 Model Card

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-27b-it")
model = AutoModelForCausalLM.from_pretrained("google/gemma-2-27b-it")

• Gemma 2 Announcement

# Accessed via X Premium subscription or xAI API
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ.get("XAI_API_KEY"), base_url="https://api.x.ai/v1")
response = client.chat.completions.create(model="grok-2-latest", messages=[{"role": "user", "content": "Hi"}])

• Grok-2 Announcement

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="gpt-4",
  messages=[{"role": "user", "content": "Hello!"}]
)

• Official GPT-4 Technical Report
• GPT-4 API Documentation

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[{"role": "user", "content": "Hello!"}]
)

• ChatGPT Blog Post

# GPT-3 is accessed via OpenAI's legacy completions API
from openai import OpenAI
client = OpenAI()
response = client.completions.create(
  model="text-davinci-003",
  prompt="Translate to French: Hello, world!",
  max_tokens=60
)

• Brown et al. (2020) - GPT-3 Paper

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-70b-chat-hf")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-70b-chat-hf")

• Touvron et al. (2023) - Llama 2 Paper

from transformers import LlamaForCausalLM, LlamaTokenizer
model = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b")
tokenizer = LlamaTokenizer.from_pretrained("meta-llama/Llama-2-7b")

• Touvron et al. (2023) - LLaMA Paper
• Meta AI Official LLaMA Page

from transformers import BertTokenizer, BertModel
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

• Devlin et al. (2018) - BERT Paper
• Official GitHub Repository

from transformers import RobertaTokenizer, RobertaModel
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaModel.from_pretrained('roberta-base')

• Liu et al. (2019) - RoBERTa Paper

from transformers import T5Tokenizer, T5ForConditionalGeneration
tokenizer = T5Tokenizer.from_pretrained("t5-base")
model = T5ForConditionalGeneration.from_pretrained("t5-base")
input_ids = tokenizer("translate English to French: Hello world", return_tensors="pt").input_ids

• Raffel et al. (2019) - T5 Paper

# Access via Google AI Studio or Vertex AI
import vertexai
from vertexai.language_models import TextGenerationModel
vertexai.init(project="YOUR_PROJECT", location="us-central1")
model = TextGenerationModel.from_pretrained("text-bison@002")
response = model.predict("Write a poem about AI.")

• PaLM 2 Technical Report

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-180B-chat")
model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-180B-chat", trust_remote_code=True)

• Falcon 180B Release

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("lmsys/vicuna-13b-v1.5")
tokenizer = AutoTokenizer.from_pretrained("lmsys/vicuna-13b-v1.5")

• Vicuna Blog Post

# Weights available on HuggingFace
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("tatsu-lab/alpaca-7b-wdiff")
tokenizer = AutoTokenizer.from_pretrained("tatsu-lab/alpaca-7b-wdiff")

• Alpaca: A Strong Open-Source LLM

# Midjourney does not offer an official public API.
# Usage is primarily through their Discord bot or web interface.
/imagine prompt: A futuristic cyberpunk city in the rain, highly detailed --v 6.0

• Midjourney Alpha

from diffusers import StableDiffusionPipeline
pipe = StableDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2")
image = pipe("a photo of an astronaut on mars").images[0]

• Rombach et al. (2022) - Latent Diffusion Paper
• Stability AI Official Site

from diffusers import DiffusionPipeline
pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0")
image = pipe(prompt="A majestic lion at sunset, 8K").images[0]

• SDXL Paper

from openai import OpenAI
client = OpenAI()
response = client.images.generate(
  model="dall-e-3",
  prompt="A cozy cabin in a snowy forest at night, cinematic lighting",
  size="1024x1024",
  quality="hd"
)

• DALL-E 3 Technical Report

from openai import OpenAI
client = OpenAI()
response = client.images.generate(
  model="dall-e-2",
  prompt="A surrealist painting of a robot reading a book",
  n=1,
  size="1024x1024"
)

• Hierarchical Text-Conditional Image Generation Paper

import clip
model, preprocess = clip.load("ViT-B/32")
image = preprocess(image).unsqueeze(0)
text = clip.tokenize(["a cat", "a dog"])

• Radford et al. (2021) - CLIP Paper
• Official CLIP Repository

from segment_anything import sam_model_registry, SamPredictor
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h.pth")
predictor = SamPredictor(sam)
predictor.set_image(image)
masks, scores, logits = predictor.predict(point_coords=input_point, point_labels=input_label)

• Kirillov et al. (2023) - SAM Paper

import whisper
model = whisper.load_model("large-v3")
result = model.transcribe("audio.mp3")
print(result["text"])

• Radford et al. (2022) - Whisper Paper

from transformers import ViTImageProcessor, ViTForImageClassification
from PIL import Image
processor = ViTImageProcessor.from_pretrained('google/vit-base-patch16-224')
model = ViTForImageClassification.from_pretrained('google/vit-base-patch16-224')

• Dosovitskiy et al. (2020) - ViT Paper

# Sora is accessible via ChatGPT Plus/Pro or the OpenAI API
# API access for developers was opened in late 2024
from openai import OpenAI
client = OpenAI()
# See official Sora docs for current API usage

• Sora Technical Report

import torchvision.models as models
model = models.resnet50(pretrained=True)
model.eval()

• He et al. (2015) - Deep Residual Learning Paper

from ultralytics import YOLO
model = YOLO("yolov8n.pt")
results = model("https://ultralytics.com/images/bus.jpg")
results[0].show()

• Ultralytics YOLOv8 Docs

# Via API or locally for open variants
from diffusers import FluxPipeline
import torch
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16)
image = pipe("A cat holding a sign that says 'Hello World'").images[0]

• FLUX.1 Announcement

# Accessed via Runway web interface or API
# Provide a descriptive prompt to generate high-fidelity video clips.

• Gen-3 Alpha Release

from audiocraft.models import MusicGen
model = MusicGen.get_pretrained('facebook/musicgen-large')
model.set_generation_params(duration=8)
wav = model.generate(["An upbeat jazz piano with drums"])

• Copet et al. (2023) - MusicGen Paper

from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
processor = LlavaNextProcessor.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf")
model = LlavaNextForConditionalGeneration.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf")

• LLaVA Paper

# Accessed via Suno web platform or API
# Prompt: "An upbeat pop song about coding late at night"

• Suno v3.5 Announcement

import requests
url = "https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
headers = {"xi-api-key": "YOUR_API_KEY", "Content-Type": "application/json"}
data = {"text": "Hello, world!", "model_id": "eleven_multilingual_v2"}
response = requests.post(url, json=data, headers=headers)

• ElevenLabs Official Site

from transformers import MllamaForConditionalGeneration, AutoProcessor
model = MllamaForConditionalGeneration.from_pretrained("meta-llama/Llama-3.2-90B-Vision-Instruct")
processor = AutoProcessor.from_pretrained("meta-llama/Llama-3.2-90B-Vision-Instruct")

• Llama 3.2 Announcement

# Codex is accessed via the OpenAI Completions API (deprecated in favor of GPT-4)
from openai import OpenAI
client = OpenAI()
response = client.completions.create(
  model="code-davinci-002",
  prompt="# Python function to sort a list\ndef sort_list(",
  max_tokens=100
)

• Chen et al. (2021) - Codex Paper

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("meta-llama/CodeLlama-34b-Instruct-hf")
model = AutoModelForCausalLM.from_pretrained("meta-llama/CodeLlama-34b-Instruct-hf")

• Code Llama Paper

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("bigcode/starcoder2-15b")
model = AutoModelForCausalLM.from_pretrained("bigcode/starcoder2-15b")

• StarCoder2 Paper

from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/deepseek-coder-33b-instruct")
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/deepseek-coder-33b-instruct")

• DeepSeek-Coder Paper

from openai import OpenAI
client = OpenAI()
response = client.embeddings.create(
  input="Your text string goes here",
  model="text-embedding-3-large"
)
embedding = response.data[0].embedding

• New Embedding Models Announcement

from sentence_transformers import SentenceTransformer
model = SentenceTransformer("intfloat/e5-mistral-7b-instruct")
embeddings = model.encode(["Hello world", "Bonjour le monde"])

• E5-Mistral Paper

import torch
import torch.nn as nn
model = nn.Sequential(
  nn.Linear(10, 20),
  nn.ReLU(),
  nn.Linear(20, 1)
)

• PyTorch Official Documentation
• GitHub Repository

import tensorflow as tf
model = tf.keras.Sequential([
  tf.keras.layers.Dense(64, activation='relu'),
  tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

• TensorFlow Official Site
• GitHub Repository

import jax
import jax.numpy as jnp

@jax.jit
def predict(params, x):
  return jnp.dot(x, params['w']) + params['b']

grad_fn = jax.grad(lambda params, x, y: jnp.mean((predict(params, x) - y)**2))

• JAX GitHub Repository

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

model = ChatOpenAI(model="gpt-4o")
response = model.invoke([HumanMessage(content="Tell me a joke.")])

• LangChain Documentation

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")

• LlamaIndex Documentation

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))

• Pedregosa et al. (2011) - Scikit-learn Paper

import keras
model = keras.Sequential([
  keras.layers.Dense(64, activation='relu'),
  keras.layers.Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy')
model.fit(x_train, y_train, epochs=10)

• Keras Official Documentation

# Install and run from terminal
$ ollama pull llama3
$ ollama run llama3

# Or use the REST API
import requests
response = requests.post('http://localhost:11434/api/generate',
  json={"model": "llama3", "prompt": "Why is the sky blue?", "stream": False})

• Ollama GitHub

from vllm import LLM, SamplingParams
llm = LLM(model="meta-llama/Meta-Llama-3-8B-Instruct")
params = SamplingParams(temperature=0.8, top_p=0.95)
outputs = llm.generate(["Tell me a fun fact about space."], params)

• Kwon et al. (2023) - vLLM Paper

from transformers import pipeline
classifier = pipeline("sentiment-analysis")
result = classifier("I love this encyclopedia!")

• Hugging Face Documentation
• Transformers Library

from openai import OpenAI
# Perplexity offers an API compatible with OpenAI's SDK
client = OpenAI(api_key="PPLX_API_KEY", base_url="https://api.perplexity.ai")
response = client.chat.completions.create(
  model="llama-3-sonar-large-32k-online",
  messages=[{"role": "user", "content": "What is the news today?"}]
)

• Perplexity API Docs

// Type a comment in VS Code to trigger Copilot
// function to parse a URL and return the domain name
function getDomain(url) {
  // Copilot suggests: return new URL(url).hostname;
}

• GitHub Copilot Features

from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")
response = client.chat.completions.create(
  model="gpt-4o",
  messages=[{"role": "user", "content": "Hello!"}]
)

• OpenAI API Documentation

import vertexai
from vertexai.generative_models import GenerativeModel
vertexai.init(project="YOUR_PROJECT", location="us-central1")
model = GenerativeModel("gemini-1.5-pro")
response = model.generate_content("Describe the water cycle.")

• Vertex AI Documentation

import boto3, json
bedrock = boto3.client('bedrock-runtime', region_name='us-east-1')
body = json.dumps({"prompt": "\n\nHuman: Hi\n\nAssistant:", "max_tokens_to_sample": 300})
response = bedrock.invoke_model(body=body, modelId='anthropic.claude-v2')

• AWS Bedrock Documentation

import wandb
wandb.init(project="my-project")
for epoch in range(10):
  loss = train_one_epoch()
  wandb.log({"loss": loss, "epoch": epoch})

• W&B Documentation

import replicate
output = replicate.run(
  "meta/meta-llama-3-70b-instruct",
  input={"prompt": "Write a haiku about AI"}
)
print("".join(output))

• Replicate Documentation

from together import Together
client = Together(api_key="YOUR_API_KEY")
response = client.chat.completions.create(
  model="meta-llama/Llama-3-70b-chat-hf",
  messages=[{"role": "user", "content": "What is RAG?"}]
)

• Together AI Documentation

from groq import Groq
client = Groq(api_key="YOUR_API_KEY")
completion = client.chat.completions.create(
  model="llama3-70b-8192",
  messages=[{"role": "user", "content": "Explain transformers quickly."}]
)

• Groq Documentation

# Cursor is a desktop application
# Use Cmd+K for inline edits
# Use Cmd+L to open chat with full codebase context
# Agent mode: Cmd+Shift+I for autonomous multi-file changes

• Cursor Official Site

# Access via Discord or https://www.midjourney.com/
/imagine prompt: Photograph of a cat wearing a spacesuit on the moon, cinematic lighting --v 6.1 --ar 16:9

• Midjourney Website

from pinecone import Pinecone, ServerlessSpec
pc = Pinecone(api_key="YOUR_API_KEY")
pc.create_index("my-index", dimension=1536, metric="cosine", spec=ServerlessSpec(cloud='aws', region='us-east-1'))
index = pc.Index("my-index")
index.upsert(vectors=[("vec1", [0.1, 0.2], {"text": "hello"})])

• Pinecone Documentation

from torchvision.datasets import ImageNet
dataset = ImageNet(root='./data', split='train')

• Deng et al. (2009) - ImageNet Paper
• Official ImageNet Website

# Access via AWS S3 public dataset
import boto3
s3 = boto3.client('s3', region_name='us-east-1')
# Browse at s3://commoncrawl/
response = s3.list_objects_v2(Bucket='commoncrawl', Prefix='crawl-data/CC-MAIN-2024-10/')

• Common Crawl Official Site

# Available on HuggingFace
from datasets import load_dataset
dataset = load_dataset("EleutherAI/pile", split="train", streaming=True)

• Gao et al. (2020) - The Pile Paper

# Access subsets via HuggingFace
from datasets import load_dataset
dataset = load_dataset("laion/laion2B-en", split="train", streaming=True)

• Schuhmann et al. (2022) - LAION-5B Paper

from torchvision.datasets import CocoDetection
dataset = CocoDetection(
  root="./data/coco/images/train2017",
  annFile="./data/coco/annotations/instances_train2017.json"
)

• Lin et al. (2014) - COCO Paper

from datasets import load_dataset
dataset = load_dataset("openwebtext", split="train")

• OpenWebText on HuggingFace

from datasets import load_dataset
dataset = load_dataset("squad_v2")
train_data = dataset['train']

• Rajpurkar et al. (2018) - SQuAD 2.0 Paper

from datasets import load_dataset
dataset = load_dataset("cais/mmlu", "all")
print(dataset['test'][0])

• Hendrycks et al. (2020) - MMLU Paper

from datasets import load_dataset
dataset = load_dataset("openai_humaneval")
print(dataset['test'][0]['prompt'])

• Chen et al. (2021) - Evaluating LLMs Trained on Code

from datasets import load_dataset
dataset = load_dataset("gsm8k", "main")
print(dataset['test'][0])

• Cobbe et al. (2021) - GSM8K Paper

from datasets import load_dataset
dataset = load_dataset("togethercomputer/RedPajama-Data-V2", name="sample-10B", split="train", streaming=True)

• RedPajama-V2 Paper

from datasets import load_dataset
dataset = load_dataset("tatsu-lab/alpaca")
print(dataset['train'][0])

• Alpaca Dataset Release

Visit chatgpt.com to interact via the web interface.

• ChatGPT Announcement

Visit claude.ai to interact via the web interface.

• Claude Announcement

Visit perplexity.ai to search and interact.

• Perplexity AI

Visit chat.deepseek.com to interact.

• DeepSeek Chat

Visit gemini.google.com to interact.

• Gemini Announcement

Visit copilot.microsoft.com or use it directly in Windows 11 / Edge.

• Copilot Announcement

Access via X Premium subscription.

• Grok Announcement

Use it directly inside Meta's messaging apps or at meta.ai.

• Meta AI Announcement

Visit huggingface.co/chat to interact.

• HuggingChat

Install the GitHub Copilot extension in VS Code or JetBrains IDEs.

• GitHub Copilot

Visit character.ai to chat with community-created characters.

• Character.ai

Visit pi.ai to interact.

• Meet Pi

Visit chat.mistral.ai to interact via the web interface.

• Mistral Le Chat

Visit poe.com or download the Poe app to access multiple AI models.

• Poe by Quora

Visit you.com to search and interact with the AI assistant.

• You.com

Visit coral.cohere.com to interact via the web interface.

• Cohere Coral

Visit yiyan.baidu.com to interact; primarily available in China.

• ERNIE Bot

Access via clova.ai or integrated directly into Naver Search and other Naver services.

• HyperCLOVA X

Download and install from cursor.com; works as a drop-in VS Code replacement.

• Cursor

Install the Tabnine extension from your IDE's marketplace (VS Code, JetBrains, Neovim, etc.).

• Tabnine

Access at replit.com; Ghostwriter is available in the editor with a Replit Core subscription.

• Replit Ghostwriter

Install the AWS Toolkit extension in VS Code or JetBrains and sign in with an AWS Builder ID.

• Amazon CodeWhisperer

Download from codeium.com/windsurf and install as a standalone IDE.

• Windsurf by Codeium

Visit bolt.new and describe the app you want to build; it generates and runs the code instantly.

• Bolt.new

Join the Midjourney Discord server at discord.gg/midjourney and use /imagine commands.

• Midjourney

Visit firefly.adobe.com or use Generative Fill directly inside Adobe Photoshop.

• Adobe Firefly

Visit leonardo.ai, create an account, and generate images using built-in or custom models.

• Leonardo.ai

Visit ideogram.ai, sign in, and generate images with text prompts including typographic elements.

• Ideogram AI

Visit playground.com to generate images for free with up to 500 images/day on the free tier.

• Playground AI

Visit creator.nightcafe.studio to generate images and participate in the community.

• NightCafe Creator

Access via app.runwayml.com; generate videos from text or image prompts through the web interface.

• Runway Gen-3 Alpha

Visit pika.art to generate and edit videos from text or image prompts.

• Pika Labs

Access via klingai.com; generate videos from text prompts or reference images.

• Kling AI

Visit heygen.com, choose an avatar or upload your own, write a script, and generate a video.

• HeyGen

Visit lumalabs.ai/dream-machine to generate videos from text or image inputs.

• Luma Dream Machine

Visit synthesia.io, write a script, choose an AI avatar, and generate a video in minutes.

• Synthesia

Visit elevenlabs.io to generate speech or use the ElevenLabs API for programmatic access.

• ElevenLabs

Visit murf.ai to type or paste text, choose a voice, and generate and download audio.

• Murf AI

Download Descript from descript.com; import audio or video and edit by modifying the transcript.

• Descript

Visit podcast.adobe.com, upload an audio file, and use Enhance Speech to clean up the recording.

• Adobe Podcast

Visit play.ht to generate speech from text or access the API for programmatic voice generation.

• Play.ht

Visit suno.com and type a prompt describing the style or lyrics to generate a full song.

• Suno AI

Visit udio.com, describe the music style or mood, and generate tracks instantly.

• Udio

Access inside any Notion workspace by pressing the spacebar or typing /AI on any page.

• Notion AI

Install the Grammarly browser extension from grammarly.com or use the desktop app.

• Grammarly

Visit copy.ai, select a content type template, enter your product info, and generate copy.

• Copy.ai

Visit jasper.ai to sign up and use the web editor for AI content generation.

• Jasper AI

Visit writesonic.com to access the editor and start generating content with templates.

• Writesonic

Visit tome.app, enter a prompt for your presentation topic, and Tome generates a full deck.

• Tome

Visit gamma.app, describe your content, and generate a fully designed presentation instantly.

• Gamma

Access at canva.com; AI tools are available within the design editor for all account types.

• Canva Magic Studio

Visit otter.ai or install the mobile app; connect to Zoom, Google Meet, or MS Teams for auto-join.

• Otter.ai

Requires a Microsoft 365 subscription with a Copilot add-on; accessible within all M365 apps.

• Microsoft 365 Copilot

Access at khanacademy.org; available to students and teachers with a Khan Academy account.

• Khanmigo by Khan Academy

Download the Socratic app on iOS or Android and take a photo of any homework question.

• Socratic by Google

Upgrade to Duolingo Max within the Duolingo iOS or Android app to access AI features.

• Duolingo Max

Visit quizlet.com or open the app; Q-Chat and AI features are available on Quizlet Plus.

• Quizlet AI

Visit elicit.com, enter a research question, and get summaries and data from relevant papers.

• Elicit

Visit consensus.app, ask a research question, and get answers backed by peer-reviewed citations.

• Consensus

Visit semanticscholar.org to search for papers and access AI-generated summaries and citations.

• Semantic Scholar

Download the Replika app on iOS or Android, or visit replika.com to chat with your AI companion.

• Replika