AI Integration Hub

Built for AI Engineers - a curated hub of AI APIs, code templates, model comparisons and engineering roadmaps designed to accelerate development and streamline AI integration.

The ultimate one-stop resource for developers building with AI.

Everything you need to go from idea → production with LLMs in one place.

✨ Why AI Integration Hub?

Building AI-powered applications is powerful but overwhelming.

Scattered documentation, constantly changing APIs, confusing pricing, and lack of practical templates slow you down.

AI Integration Hub solves this by giving you:

Curated API directory with latest keys & pricing
Up-to-date model comparison table
Production-ready code templates
Learning roadmaps for RAG, Agents, Fine-tuning & more
Best practices for security, prompting & cost control

🚀 Getting Started

New here? Three ways to use this repo:

Read the README - browse the API directory, model table, and code templates right here on GitHub
Visit the live site - ai-integration-hub-v1.vercel.app for an interactive, filterable experience
Grab a template - copy a code snippet from the Templates section and drop it into your project

No installation needed. No sign-up. Just open and use.

📁 API Directory

A comprehensive directory of AI API providers with essential information for quick reference.

Provider	API Key Link	Free Tier	Pricing Page	Model Types	Documentation
OpenAI	Get Key	✅ $5 credit	Pricing	LLM, Embeddings, Vision, Audio, TTS	Docs
Google AI Studio	Get Key	✅ 60 req/min	Pricing	LLM, Embeddings, Vision, Audio	Docs
Anthropic	Get Key	❌	Pricing	LLM, Vision	Docs
Cohere	Get Key	✅ Limited	Pricing	LLM, Embeddings, Rerank	Docs
Mistral AI	Get Key	✅ Trial credits	Pricing	LLM, Embeddings, Vision	Docs
Groq	Get Key	✅ Limited	Pricing	LLM, Vision, Audio	Docs
DeepSeek	Get Key	✅ Credits	Pricing	LLM	Docs
Perplexity	Get Key	❌	Pricing	LLM, Search	Docs
Together AI	Get Key	✅ $25 credit	Pricing	LLM, Embeddings, Image	Docs
Fireworks AI	Get Key	✅ Limited	Pricing	LLM, Image, Audio	Docs
Replicate	Get Key	❌	Pricing	LLM, Image, Audio, Video	Docs
Hugging Face	Get Key	✅ Limited	Pricing	LLM, Embeddings, All	Docs
Voyage AI	Get Key	✅ Limited	Pricing	Embeddings, Rerank	Docs
ElevenLabs	Get Key	✅ 10k chars	Pricing	TTS, Voice	Docs
AssemblyAI	Get Key	✅ Limited	Pricing	STT, TTS, Understanding	Docs
xAI (Grok)	Get Key	❌	Pricing	LLM, Vision	Docs
OpenRouter	Get Key	✅ Limited	Pricing	LLM (100+ models)	Docs
Cerebras	Get Key	✅ Limited	Pricing	LLM (ultra-fast inference)	Docs

💻 Ready-to-Use Code Templates

Save hours of setup time with production-ready code templates.

Python Examples

OpenAI Chat Completion

import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"}
    ],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)

OpenAI Streaming

import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Tell me a story."}],
    max_tokens=1024,
    stream=True,
)

for chunk in stream:
    text = chunk.choices[0].delta.content or ""
    print(text, end="", flush=True)

Anthropic Claude

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello!"}
    ]
)

print(response.content[0].text)

Anthropic Streaming

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Tell me a story."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Google Gemini

import os
import google.generativeai as genai

genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
model = genai.GenerativeModel("gemini-2.5-flash")

response = model.generate_content("Hello!")
print(response.text)

Node.js Examples

OpenAI with Node.js

import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello!' }
  ],
  temperature: 0.7,
  max_tokens: 1024
});

console.log(response.choices[0].message.content);

OpenAI Streaming (Node.js)

import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const stream = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Tell me a story.' }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

Groq Fast Inference

import Groq from 'groq-sdk';

const groq = new Groq({ apiKey: process.env.GROQ_API_KEY });

const response = await groq.chat.completions.create({
  model: 'llama-3.3-70b-versatile',
  messages: [{ role: 'user', content: 'Hello!' }],
  temperature: 0.7,
  max_tokens: 1024
});

console.log(response.choices[0].message.content);

LangChain Integration

Basic RAG Pipeline

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA  # use LCEL chain in new projects

# Load documents
loader = PyPDFLoader("document.pdf")
documents = loader.load()

# Split text
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_documents(documents)

# Create embeddings and vector store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)

# Create QA chain
llm = ChatOpenAI(model="gpt-4o", temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

# Query
response = qa_chain.invoke({"query": "Your question here"})

LangChain Agent

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain_community.utilities import SerpAPIWrapper
from langchain_core.tools import Tool
from langchain import hub

search = SerpAPIWrapper()
tools = [
    Tool(
        name="Search",
        func=search.run,
        description="Useful for answering questions about current events"
    )
]

llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

response = agent_executor.invoke({"input": "What's the weather in Tokyo?"})

LlamaIndex Integration

Simple RAG with LlamaIndex

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
from llama_index.llms.openai import OpenAI

# Load documents
documents = SimpleDirectoryReader("./data").load_data()

# Create index
index = VectorStoreIndex.from_documents(documents)

# Query engine
llm = OpenAI(model="gpt-4o")
query_engine = index.as_query_engine(llm=llm)
response = query_engine.query("Your question here")
print(response)

LlamaIndex with Multiple Data Sources

from llama_index.core import Settings
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI

# Configure settings
Settings.llm = OpenAI(model="gpt-4o")
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# Build index from multiple sources
from llama_index.core import StorageContext, load_index_from_storage

# Persist and load
index.storage_context.persist()
storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)

RAG Templates

Advanced RAG with Hybrid Search

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever
from langchain_community.vectorstores import Chroma

# True hybrid: semantic similarity + BM25 keyword search
semantic_retriever = vectorstore.as_retriever(search_type="similarity", k=5)
bm25_retriever = BM25Retriever.from_documents(documents, k=5)

ensemble_retriever = EnsembleRetriever(
    retrievers=[semantic_retriever, bm25_retriever],
    weights=[0.6, 0.4]
)

Multi-Query RAG

from langchain.retrievers.multi_query import MultiQueryRetriever
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0)
retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(),
    llm=llm
)

# Generates multiple query variations for better retrieval
results = retriever.invoke("Your complex question")

📊 Model Comparison Table

Compare top AI models across key dimensions.

Model	Provider	Context Window	Vision	Cost (Input/1M)	Cost (Output/1M)	Free Tier
GPT-4.1	OpenAI	1M	✅	$2.00	$8.00	❌
GPT-4o	OpenAI	128K	✅	$2.50	$10.00	❌
GPT-4o-mini	OpenAI	128K	✅	$0.15	$0.60	✅
Claude Sonnet 4.6	Anthropic	1M	✅	$3.00	$15.00	❌
Claude Opus 4.7	Anthropic	1M	✅	$5.00	$25.00	❌
Claude Haiku 4.5	Anthropic	200K	✅	$1.00	$5.00	❌
Gemini 2.5 Flash	Google	1M	✅	$0.30	$2.50	✅
Gemini 2.5 Pro	Google	1M	✅	$1.25	$10.00	✅
Llama 3.3 70B	Meta	128K	❌	~$0.59	~$0.79	✅ (Self-host)
DeepSeek R1	DeepSeek	128K	❌	$0.55	$2.19	✅
Mistral Large 2	Mistral	128K	✅	$2.00	$6.00	❌
Mistral Small 3	Mistral	128K	❌	$0.10	$0.30	✅
DeepSeek V3	DeepSeek	128K	❌	$0.27	$1.10	✅
Command R+	Cohere	128K	❌	$2.50	$10.00	✅
Grok-3	xAI	131K	✅	$3.00	$15.00	❌
Llama 3.3 70B (Groq)	Groq	128K	❌	~$0.59	~$0.79	✅

→ Full Comparison Table

💡 Note: Pricing is approximate and may vary. Always verify current rates before committing. Self-hosted models require infrastructure costs.

🎯 Which Model Should I Use?

Quick decision guide for common use cases.

Decision Tree

┌─────────────────────────────────────────────────────────────┐
│                    START: Choose Your Use Case              │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
   ┌─────────┐          ┌──────────┐          ┌──────────┐
   │Chatbot/ │          │Fast & Low│          │Cost-     │
   │Assistant│          │Latency   │          │Effective │
   └────┬────┘          └────┬─────┘          └────┬─────┘
        │                    │                     │
        ▼                    ▼                     ▼
   ┌─────────┐          ┌──────────┐          ┌──────────┐
   │GPT-4o   │          │Groq      │          │GPT-4o-   │
   │Claude   │          │Cerebras  │          │mini      │
   │Gemini   │          │(Fast)    │          │Haiku     │
   │(Quality)│          │          │          │(Cheap)   │
   └─────────┘          └──────────┘          └──────────┘

By Use Case

Use Case	Recommended Models	Why
🤖 Chatbot / Customer Service	GPT-4o, Claude Sonnet 4.6, Gemini 2.5 Flash	Best conversational ability, safety, and reliability
⚡ Fast Inference / Real-time	Groq (Llama 3.3), Cerebras, GPT-4o-mini	Sub-second latency, high throughput
💰 Budget-Friendly	GPT-4o-mini, Claude Haiku 4.5, DeepSeek V3	Lowest cost per token with good quality
📄 Long Document Analysis	Claude Sonnet 4.6 (1M), Gemini 2.5 Pro (1M)	Largest context windows
👁️ Vision / Image Understanding	GPT-4o, Claude Sonnet 4.6, Gemini 2.5 Flash	Best multimodal capabilities
🔍 Embeddings	text-embedding-3-small, Voyage-3, Cohere	High quality, cost-effective
🔎 Reranking	Voyage Rerank, Cohere Rerank	Best retrieval accuracy
🖼️ Image Generation	DALL-E 3, Midjourney, Stable Diffusion	Quality and control
🎤 Speech-to-Text	Whisper, AssemblyAI, Deepgram	Accuracy and language support
🔊 Text-to-Speech	ElevenLabs, OpenAI TTS	Natural voice quality
🏠 Self-Hosted / Open Source	Llama 3.3, Qwen 2.5, Mistral	Full control, no API costs
📊 Code Generation	Claude Sonnet 4.6, GPT-4.1, DeepSeek V3	Best coding capabilities
🔬 Research / Analysis	Claude Opus 4.7, GPT-4o, Grok-3	Reasoning and accuracy
🌐 Multi-Model Access	OpenRouter	One API key for 100+ models

Quick Recommendations

# Production Chatbot
model: claude-sonnet-4-6
provider: Anthropic
reason: Best balance of speed, quality, and safety

# MVP / Prototype
model: gpt-4o-mini
provider: OpenAI
reason: Cheap, fast, good enough for testing

# Enterprise / High-Stakes
model: gpt-4o
provider: OpenAI
reason: Most reliable, best support

# High Volume / Cost-Sensitive
model: llama-3.3-70b-versatile
provider: Groq
reason: Fast and affordable

# Long Context Needs
model: gemini-2.5-pro
provider: Google
reason: 1M token context window with best-in-class reasoning

# Exploring Multiple Models
model: any
provider: OpenRouter
reason: Access 100+ models via one unified API

🗺 AI Engineering Roadmaps

Comprehensive guides for mastering AI engineering skills.

📚 RAG (Retrieval-Augmented Generation)

Learning Path:

Fundamentals
- Understanding embeddings
- Vector databases (Chroma, Pinecone, Weaviate)
- Chunking strategies
Implementation
- Basic RAG pipeline
- Hybrid search (semantic + keyword)
- Query transformation
Advanced
- Multi-query retrieval
- Parent document retrieval
- Hypothetical Document Embeddings (HyDE)
- RAG fusion
Optimization
- Retrieval evaluation
- Chunk size optimization
- Re-ranking strategies

Resources:

🤖 Agents

Learning Path:

Fundamentals
- Agent architectures (ReAct, Plan-and-Solve)
- Tool usage and function calling
- Memory management
Implementation
- Single-agent systems
- Multi-agent collaboration
- Tool integration (APIs, databases, search)
Advanced
- Autonomous agents
- Human-in-the-loop
- Agent orchestration (CrewAI, AutoGen)
Production
- Agent evaluation
- Safety and guardrails
- Monitoring and logging

Resources:

🔧 Fine-tuning

Learning Path:

Fundamentals
- When to fine-tune vs. prompt engineering
- Dataset preparation
- Training vs. inference costs
Implementation
- Full fine-tuning
- LoRA (Low-Rank Adaptation)
- QLoRA (Quantized LoRA)
Platforms
- OpenAI Fine-tuning
- Hugging Face Transformers
- Together AI, Fireworks
Evaluation
- Validation strategies
- Benchmark datasets
- Performance metrics

Resources:

🔌 MCP (Model Context Protocol)

Learning Path:

Fundamentals
- Understanding MCP architecture
- Servers and clients
- Resource exposure
Implementation
- Building MCP servers
- Connecting to AI assistants
- Resource types (prompts, tools, resources)
Advanced
- Custom MCP servers
- Integration with existing systems
- Security considerations

Resources:

🗄️ Vector Databases

Learning Path:

Fundamentals
- Vector embeddings explained
- Similarity search algorithms
- Index types (HNSW, IVF, etc.)
Platforms
- Chroma - Simple, embedded
- Pinecone - Managed, scalable
- Weaviate - Hybrid search
- Qdrant - Open-source, fast
- Milvus - Large-scale
Implementation
- Schema design
- Metadata filtering
- Hybrid search
Optimization
- Index tuning
- Query optimization
- Scaling strategies

Resources:

📈 Evaluation

Learning Path:

Fundamentals
- Evaluation metrics (accuracy, relevance, faithfulness)
- Human vs. automated evaluation
- Benchmark datasets
Tools
- Ragas - RAG evaluation
- Arize Phoenix - Tracing and eval
- LangSmith - End-to-end platform
- DeepEval - LLM evaluation
Implementation
- Setting up eval pipelines
- Continuous evaluation
- A/B testing
Advanced
- LLM-as-a-judge
- Custom metrics
- Production monitoring

Resources:

🚀 MLOps for AI

Learning Path:

Fundamentals
- ML lifecycle for LLMs
- Version control for prompts/models
- CI/CD for AI
Implementation
- Prompt versioning
- Model registry
- Experiment tracking
Monitoring
- Latency tracking
- Cost monitoring
- Quality drift detection
Production
- Rate limiting
- Caching strategies
- Fallback mechanisms

Resources:

✍ Prompt Engineering Guide

Prompt engineering is one of the highest-leverage skills in AI development. A well-crafted prompt can dramatically improve output quality without changing the model or spending more on fine-tuning.

Core Principles

Principle	Bad Example	Good Example
Be specific	"Summarize this"	"Summarize this article in 3 bullet points, each under 20 words, for a non-technical audience"
Set a role	"Fix this code"	"You are a senior Python engineer. Review this code for bugs, performance issues, and style violations"
Constrain the output	"List ideas"	"List exactly 5 product name ideas. Format: one per line, no numbering, no explanation"
Use examples	"Write a tweet"	"Write a tweet in this style: 'Just shipped dark mode. Your eyes will thank us. 🌙'"

System Prompt Template

You are a [ROLE] helping [TARGET USER] with [TASK DOMAIN].

Your responses should:
- [TONE/STYLE constraint]
- [FORMAT constraint]
- [LENGTH constraint]

Always:
- [POSITIVE behavior]
- [POSITIVE behavior]

Never:
- [NEGATIVE behavior]
- [NEGATIVE behavior]

Few-Shot Prompting

prompt = """
Classify the sentiment of each review as POSITIVE, NEGATIVE, or NEUTRAL.

Review: "The battery life is incredible!"
Sentiment: POSITIVE

Review: "Arrived broken and support ignored me."
Sentiment: NEGATIVE

Review: "It works as described."
Sentiment: NEUTRAL

Review: "{user_review}"
Sentiment:
"""

Chain-of-Thought Prompting

# Add "Think step by step" or show a worked example to activate reasoning
prompt = """
Solve this problem. Think step by step before giving your final answer.

Problem: A store sells apples for $0.50 each and oranges for $0.75 each.
If Maria buys 4 apples and 3 oranges, how much does she spend in total?
"""

Structured Output (JSON)

prompt = """
Extract the following fields from the invoice text and return ONLY valid JSON.

Fields: vendor_name, invoice_date, total_amount, currency

Invoice text:
{invoice_text}

Return format:
{
  "vendor_name": "...",
  "invoice_date": "YYYY-MM-DD",
  "total_amount": 0.00,
  "currency": "USD"
}
"""

Resources:

🔐 Security & Key Management

Protecting your API keys is non-negotiable. A leaked key can result in unexpected charges, data exposure, or service abuse.

Never Do This ❌

# NEVER hardcode keys — even in "private" repos
client = OpenAI(api_key="sk-proj-abc123...")

# NEVER commit .env files
git add .env  # ← This will haunt you

Always Do This ✅

1. Use environment variables

# .env (add to .gitignore immediately)
OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...

# Python
from dotenv import load_dotenv
import os

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

// Node.js
import "dotenv/config";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

2. Add .env to .gitignore before your first commit

echo ".env" >> .gitignore
echo ".env.local" >> .gitignore

3. Use secrets managers in production

Platform	Service
AWS	Secrets Manager / Parameter Store
GCP	Secret Manager
Azure	Key Vault
Vercel / Netlify	Environment Variables UI
Docker / K8s	Secrets or sealed-secrets

4. Rotate keys regularly and on any suspected leak

Most providers let you invalidate and regenerate keys from their dashboard instantly. Set a reminder to rotate every 90 days.

5. Scope permissions when possible

Prefer read-only keys where write access isn't needed
Use per-project keys so a leak only exposes one project
Enable usage alerts to catch unexpected spikes early

⚡ Rate Limits & Cost Estimation

Understanding rate limits and costs before you build prevents nasty surprises at scale.

Rate Limit Cheat Sheet

Provider	Free Tier RPM	Free Tier TPM	Paid Tier RPM
OpenAI	3	40K	500–10,000
Anthropic	No free tier	N/A	50–4,000
Google AI	15	1M	1,000+
Groq	30	14.4K	100–6,000
Mistral	1	500K	500+
Cohere	5	-	10,000+
Together AI	60	-	Varies

RPM = Requests Per Minute · TPM = Tokens Per Minute · Tiers vary by model and plan — always verify on provider dashboards.

Quick Cost Estimation Formula

Estimated monthly cost =
  (avg_tokens_per_request × requests_per_day × 30)
  ÷ 1,000,000
  × price_per_million_tokens

Example: 500 tokens/request × 1,000 requests/day × 30 days = 15M tokens/month At GPT-4o-mini input pricing ($0.15/1M): $2.25/month input cost

Handling Rate Limit Errors

import time
import openai

def call_with_retry(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gpt-4o-mini",
                messages=messages
            )
        except openai.RateLimitError:
            wait = 2 ** attempt  # exponential backoff: 1s, 2s, 4s, 8s...
            print(f"Rate limited. Retrying in {wait}s...")
            time.sleep(wait)
    raise Exception("Max retries exceeded")

Cost Control Tips

Use max_tokens on every request to cap runaway outputs
Cache repeated prompts with Redis or a simple dict
Use cheaper models for classification/routing, expensive ones only for generation
Monitor spend daily during development — most providers have usage alert webhooks

🔥 Awesome AI APIs

Categorized collection of the best AI APIs available.

🧠 LLM APIs

API	Provider	Best For	Free Tier
OpenAI API	OpenAI	General purpose, reliability	✅
Anthropic API	Anthropic	Long context, safety	❌
Google AI	Google	Multimodal, long context	✅
Groq	Groq	Speed, low latency	✅
Together AI	Together	Open-source models	✅
Fireworks AI	Fireworks	Fast inference	✅
DeepSeek	DeepSeek	Cost-effective	✅
Perplexity API	Perplexity	Search + LLM	❌
xAI Grok	xAI	Reasoning, real-time data	❌
OpenRouter	OpenRouter	Multi-model unified API	✅
Cerebras	Cerebras	Ultra-fast inference	✅

👁️ Vision APIs

API	Provider	Capabilities	Free Tier
GPT-4 Vision	OpenAI	Image understanding	❌
Claude Vision	Anthropic	Document analysis	❌
Gemini Vision	Google	Multimodal	✅
Azure Computer Vision	Microsoft	OCR, analysis	✅
Clarifai	Clarifai	Custom models	✅

🎤 Speech-to-Text APIs

API	Provider	Languages	Free Tier
Whisper API	OpenAI	99+	❌
AssemblyAI	AssemblyAI	30+	✅
Deepgram	Deepgram	30+	✅
Google Speech-to-Text	Google	125+	✅
Azure Speech	Microsoft	100+	✅

🔊 Text-to-Speech APIs

API	Provider	Voices	Free Tier
ElevenLabs	ElevenLabs	30+	✅
OpenAI TTS	OpenAI	6	❌
Google TTS	Google	300+	✅
Azure TTS	Microsoft	400+	✅
PlayHT	PlayHT	800+	✅

📷 OCR APIs

API	Provider	Best For	Free Tier
Azure OCR	Microsoft	Documents	✅
Google Vision	Google	General	✅
AWS Textract	Amazon	Forms/Tables	❌
Mindee	Mindee	Invoices	✅
OCR.space	OCR.space	Simple	✅

🎨 Image Generation APIs

API	Provider	Style	Free Tier
DALL-E 3	OpenAI	Realistic	❌
Midjourney	Midjourney	Artistic	❌
Stable Diffusion	Stability AI	Custom	✅
Leonardo AI	Leonardo	Games/Art	✅
Flux	Black Forest Labs	High quality	❌

🔄 Reranker APIs

API	Provider	Best For	Free Tier
Voyage Rerank	Voyage AI	RAG accuracy	✅
Cohere Rerank	Cohere	General	✅
Jina Rerank	Jina AI	Cost-effective	✅
BGE Rerank	FlagEmbedding	Open-source	✅

📐 Embedding APIs

API	Provider	Dimensions	Free Tier
text-embedding-3-small	OpenAI	1536	❌
text-embedding-3-large	OpenAI	3072	❌
Voyage-3	Voyage AI	1024	✅
Cohere Embed	Cohere	1024	✅
Mistral Embed	Mistral	1024	✅
Jina Embed	Jina AI	1024	✅
Nomic Embed	Nomic	768	✅

📊 Additional Useful APIs

Category	API	Provider
Web Search	Tavily	Tavily
Web Search	Serper	Serper
Code Execution	E2B	E2B
Browser Automation	Browserbase	Browserbase
PDF Processing	LlamaParse	LlamaIndex
Data Extraction	Diffbot	Diffbot
Sentiment Analysis	MeaningCloud	MeaningCloud

🤝 Contributing

See CONTRIBUTING.md for detailed guidelines and CHANGELOG.md for version history.

Here's the quick version:

Fork the repository
Create a feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'feat: add Cerebras to API directory')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

Contribution Guidelines

Add new API providers with complete information
Include working code examples
Update model comparison tables when pricing changes
Add new roadmap topics or improve existing ones
Fix typos and improve documentation

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🌟 Support

If you find this repository helpful, please:

⭐ Star this repository
🔗 Share with your colleagues
💡 Suggest improvements via Issues

📬 Contact

Issues: GitHub Issues
Discussions: GitHub Discussions

Made with ❤️ for the AI Engineering Community

⬆ Back to Top

Name		Name	Last commit message	Last commit date
Latest commit History 8 Commits
.github		.github
docs		docs
public/images		public/images
src		src
templates		templates
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
index.html		index.html
package-lock.json		package-lock.json
package.json		package.json
tsconfig.json		tsconfig.json
vite.config.ts		vite.config.ts

Folders and files

Latest commit

History

Repository files navigation

AI Integration Hub

✨ Why AI Integration Hub?

🚀 Getting Started

📋 Table of Contents

📁 API Directory

💻 Ready-to-Use Code Templates

Python Examples

OpenAI Chat Completion

OpenAI Streaming

Anthropic Claude

Anthropic Streaming

Google Gemini

Node.js Examples

OpenAI with Node.js

OpenAI Streaming (Node.js)

Groq Fast Inference

LangChain Integration

Basic RAG Pipeline

LangChain Agent

LlamaIndex Integration

Simple RAG with LlamaIndex

LlamaIndex with Multiple Data Sources

RAG Templates

Advanced RAG with Hybrid Search

Multi-Query RAG

📊 Model Comparison Table

🎯 Which Model Should I Use?

Decision Tree

By Use Case

Quick Recommendations

🗺 AI Engineering Roadmaps

📚 RAG (Retrieval-Augmented Generation)

🤖 Agents

🔧 Fine-tuning

🔌 MCP (Model Context Protocol)

🗄️ Vector Databases

📈 Evaluation

🚀 MLOps for AI

✍ Prompt Engineering Guide

Core Principles

System Prompt Template

Few-Shot Prompting

Chain-of-Thought Prompting

Structured Output (JSON)

🔐 Security & Key Management

Never Do This ❌

Always Do This ✅

⚡ Rate Limits & Cost Estimation

Rate Limit Cheat Sheet

Quick Cost Estimation Formula

Handling Rate Limit Errors

Cost Control Tips

🔥 Awesome AI APIs

🧠 LLM APIs

👁️ Vision APIs

🎤 Speech-to-Text APIs

🔊 Text-to-Speech APIs

📷 OCR APIs

🎨 Image Generation APIs

🔄 Reranker APIs

📐 Embedding APIs

📊 Additional Useful APIs

🤝 Contributing

Contribution Guidelines

📄 License

🌟 Support

📬 Contact

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Packages