Say you have an app and you want it to make simple queries to an LLM — without spinning up a full-blown agent framework like Claude Code or Gemini CLI. Agents are great, but they can turn a single question into many round-trips, and with token-based pricing that adds up fast.
Below are minimal, self-contained examples for querying Claude, OpenAI, and Gemini across four approaches: raw HTTP (Python and Bash), the provider SDKs (Python and TypeScript), and LangChain for a unified interface across all three.
All examples take the query as a quoted command-line argument and read API keys from the
environment (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY).
Many apps that host local LLM's support the OpenAI REST and SDK interfaces, including Ollama and LM Studio among others.
Each example posts directly to the provider's HTTP endpoint using the requests library —
no SDK required.
import sys
import os
import requests
response = requests.post(
"https://api.anthropic.com/v1/messages",
headers={
"x-api-key": os.environ["ANTHROPIC_API_KEY"],
"anthropic-version": "2023-06-01",
"content-type": "application/json",
},
json={
"model": "claude-haiku-4-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": sys.argv[1]}],
},
)
print(response.json()["content"][0]["text"])import sys
import os
import requests
query = sys.argv[1]
response = requests.post(
"https://api.openai.com/v1/chat/completions",
headers={
"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
"Content-Type": "application/json",
},
json={
"model": "gpt-4o-mini",
"messages": [{"role": "user", "content": query}],
},
)
print(response.json()["choices"][0]["message"]["content"])Gemini exposes an OpenAI-compatible endpoint, so you can point the OpenAI client at Gemini's base URL:
import sys
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["GEMINI_API_KEY"],
base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
)
# uses the OpenAI-compatible Gemini endpoint
response = client.chat.completions.create(
model="gemini-3.1-flash-lite",
messages=[{"role": "user", "content": sys.argv[1]}],
)
print(response.choices[0].message.content)The same REST calls via curl, with JSON constructed inline using Python. Useful for shell
scripts that need a quick LLM call with no Python dependencies to install.
#!/usr/bin/env bash
set -euo pipefail
if [[ $# -lt 1 ]]; then
echo "Usage: $0 \"prompt\"" >&2
exit 1
fi
response=$(curl -sS https://api.anthropic.com/v1/messages \
-H "x-api-key: ${ANTHROPIC_API_KEY:?ANTHROPIC_API_KEY is required}" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d "$(printf '%s' \"$1\" | python -c 'import json,sys; print(json.dumps({"model":"claude-haiku-4-5","max_tokens":1024,"messages":[{"role":"user","content":sys.stdin.read()}]}))')")
printf '%s' "$response" | python -c 'import json,sys; print(json.load(sys.stdin)["content"][0]["text"])'#!/usr/bin/env bash
set -euo pipefail
if [[ $# -lt 1 ]]; then
echo "Usage: $0 \"prompt\"" >&2
exit 1
fi
response=$(curl -sS https://api.openai.com/v1/chat/completions \
-H "Authorization: Bearer ${OPENAI_API_KEY:?OPENAI_API_KEY is required}" \
-H "Content-Type: application/json" \
-d "$(printf '%s' "$1" | python -c 'import json,sys; print(json.dumps({"model":"gpt-4o-mini","messages":[{"role":"user","content":sys.stdin.read()}]}))')")
printf '%s' "$response" | python -c 'import json,sys; print(json.load(sys.stdin)["choices"][0]["message"]["content"])'Gemini's OpenAI-compatible endpoint works here too — just swap the URL and key.
#!/usr/bin/env bash
set -euo pipefail
if [[ $# -lt 1 ]]; then
echo "Usage: $0 \"prompt\"" >&2
exit 1
fi
response=$(curl -sS https://generativelanguage.googleapis.com/v1beta/openai/chat/completions \
-H "Authorization: Bearer ${GEMINI_API_KEY:?GEMINI_API_KEY is required}" \
-H "Content-Type: application/json" \
-d "$(printf '%s' \"$1\" | python -c 'import json,sys; print(json.dumps({"model":"gemini-3.1-flash-lite","messages":[{"role":"user","content":sys.stdin.read()}]}))')")
printf '%s' "$response" | python -c 'import json,sys; print(json.load(sys.stdin)["choices"][0]["message"]["content"])'Using the official provider SDKs gives you typed responses, automatic retries, and cleaner error handling compared to raw HTTP.
import sys
import os
import anthropic
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
message = client.messages.create(
model="claude-haiku-4-5",
max_tokens=1024,
messages=[{"role": "user", "content": sys.argv[1]}],
)
print(message.content[0].text)import sys
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": sys.argv[1]}],
)
print(response.choices[0].message.content)import sys
import os
from google import genai
client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
response = client.models.generate_content(
model="gemini-3.1-flash-lite",
contents=sys.argv[1],
)
print(response.text)LangChain provides a unified interface across all three providers:
import sys
import os
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.messages import HumanMessage
def format_content(content):
if isinstance(content, str):
return content
if isinstance(content, list):
parts = []
for part in content:
if isinstance(part, str):
parts.append(part)
elif isinstance(part, dict) and "text" in part:
parts.append(part["text"])
return "".join(parts)
return str(content)
query = sys.argv[1]
models = [
("OpenAI", ChatOpenAI(model="gpt-4o-mini", api_key=os.environ["OPENAI_API_KEY"])),
("Claude", ChatAnthropic(model="claude-haiku-4-5", api_key=os.environ["ANTHROPIC_API_KEY"])),
("Gemini", ChatGoogleGenerativeAI(model="gemini-3.1-flash-lite", google_api_key=os.environ["GEMINI_API_KEY"])),
]
for name, model in models:
response = model.invoke([HumanMessage(content=query)])
print(f"=== {name} ===")
print(format_content(response.content))
print()The same SDK calls in TypeScript. Run directly with npx tsx <file>.ts "your query" — no
separate compile step needed.
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({ apiKey: process.env["ANTHROPIC_API_KEY"] });
async function main(): Promise<void> {
const query = process.argv[2];
if (!query) {
throw new Error('Pass the query as a quoted string, for example: "hello"');
}
const message = await client.messages.create({
model: "claude-haiku-4-5",
max_tokens: 1024,
messages: [{ role: "user", content: query }],
});
const text = message.content
.filter((block) => block.type === "text")
.map((block) => block.text)
.join("\n");
console.log(text);
}
void main();import OpenAI from "openai";
const client = new OpenAI({ apiKey: process.env["OPENAI_API_KEY"] });
async function main(): Promise<void> {
const query = process.argv[2];
if (!query) {
throw new Error('Pass the query as a quoted string, for example: "hello"');
}
const response = await client.chat.completions.create({
model: "gpt-4o-mini",
messages: [{ role: "user", content: query }],
});
console.log(response.choices[0]?.message?.content ?? "");
}
void main();import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ apiKey: process.env["GEMINI_API_KEY"] });
async function main(): Promise<void> {
const query = process.argv[2];
if (!query) {
throw new Error('Pass the query as a quoted string, for example: "hello"');
}
const response = await client.models.generateContent({
model: "gemini-3.1-flash-lite",
contents: query,
});
console.log(response.text);
}
void main();LangChain provides a unified interface across all three providers:
import { HumanMessage } from "@langchain/core/messages";
import { ChatAnthropic } from "@langchain/anthropic";
import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
import { ChatOpenAI } from "@langchain/openai";
function formatContent(content: unknown): string {
if (typeof content === "string") {
return content;
}
if (!Array.isArray(content)) {
return String(content ?? "");
}
return content
.map((part) => {
if (typeof part === "string") {
return part;
}
if (part && typeof part === "object" && "text" in part) {
const text = part.text;
return typeof text === "string" ? text : "";
}
return "";
})
.join("");
}
async function main(): Promise<void> {
const query = process.argv[2];
if (!query) {
throw new Error('Pass the query as a quoted string, for example: "hello"');
}
const models = [
["OpenAI", new ChatOpenAI({ model: "gpt-4o-mini", apiKey: process.env["OPENAI_API_KEY"] })],
["Claude", new ChatAnthropic({ model: "claude-haiku-4-5", apiKey: process.env["ANTHROPIC_API_KEY"] })],
[
"Gemini",
new ChatGoogleGenerativeAI({
model: "gemini-3.1-flash-lite",
apiKey: process.env["GEMINI_API_KEY"],
}),
],
] as const;
for (const [name, model] of models) {
const response = await model.invoke([new HumanMessage(query)]);
console.log(`=== ${name} ===`);
console.log(formatContent(response.content));
console.log();
}
}
void main();