Framework Integrations

The 0G AI SDK integrates seamlessly with popular AI frameworks and libraries, bringing decentralized compute to your existing workflows.

Available Providers

Choose your preferred AI framework to get started with 0G decentralized compute. Click on any provider to view the integration progress:

LangChain

The most popular framework for building LLM applications with chains, agents, and memoryStatus: 🔄 In Progress - View PR

Vercel AI SDK

React-first AI SDK for building conversational UIs with streaming and type safetyStatus: 🔄 In Progress - View PR

OpenRouter

Unified API for accessing multiple AI models with intelligent routing and fallbacksStatus: 🔄 In Progress - View PR

LlamaIndex

Data framework for building RAG applications with advanced document processingStatus: 🔄 In Progress - View PR

Integration Status

All integrations are currently under active development. Each provider card above links directly to the GitHub pull request where you can:

📋 Track Progress: See the current status of the integration
💬 Join Discussion: Participate in technical discussions
🔍 Review Code: Examine the implementation details
📝 Provide Feedback: Share your thoughts and suggestions

Want to see detailed documentation and examples? Visit our individual provider pages: LangChain, Vercel AI SDK, OpenRouter, and LlamaIndex.

Supported Models

Model	Provider Address	Best For	Framework Support
llama-3.3-70b-instruct	`0xf07240Efa67755B5311bc75784a061eDB47165Dd`	General AI tasks, conversations, content generation	All frameworks
deepseek-r1-70b	`0x3feE5a4dd5FDb8a32dDA97Bed899830605dBD9D3`	Complex reasoning, analysis, code generation	All frameworks

LangChain Integration

LangChain 0G Provider

Official LangChain integration for 0G decentralized compute

Installation

pip install langchain-nebula

Basic Usage

from langchain_0g import ZGChat
from langchain.schema import HumanMessage, SystemMessage

# Initialize with 0G provider
llm = ZGChat(
    provider_address="0xf07240Efa67755B5311bc75784a061eDB47165Dd",  # llama-3.3-70b-instruct
    private_key="your-private-key",
    temperature=0.7,
    max_tokens=1000
)

# Simple chat
response = llm.invoke([
    SystemMessage(content="You are a helpful AI assistant."),
    HumanMessage(content="Explain quantum computing in simple terms.")
])

print(response.content)

Advanced LangChain Features

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# Create a prompt template
prompt = PromptTemplate(
    input_variables=["topic", "audience"],
    template="Explain {topic} to a {audience} audience in a clear and engaging way."
)

# Create chain with 0G LLM
chain = LLMChain(
    llm=ZGChat(
        provider_address="0xf07240Efa67755B5311bc75784a061eDB47165Dd",
        private_key="your-private-key"
    ),
    prompt=prompt
)

# Run the chain
result = chain.run(topic="blockchain technology", audience="beginner")
print(result)

from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool

# Define custom tools
def calculate_tool(expression: str) -> str:
    """Calculate mathematical expressions"""
    try:
        return str(eval(expression))
    except:
        return "Invalid expression"

tools = [
    Tool(
        name="Calculator",
        func=calculate_tool,
        description="Useful for mathematical calculations"
    )
]

# Initialize agent with 0G LLM
agent = initialize_agent(
    tools=tools,
    llm=ZGChat(
        provider_address="0x3feE5a4dd5FDb8a32dDA97Bed899830605dBD9D3",  # deepseek-r1-70b for reasoning
        private_key="your-private-key",
        temperature=0.1
    ),
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Use the agent
result = agent.run("What is 15 * 24 + 100?")
print(result)

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Create memory-enabled conversation
memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=ZGChat(
        provider_address="0xf07240Efa67755B5311bc75784a061eDB47165Dd",
        private_key="your-private-key"
    ),
    memory=memory,
    verbose=True
)

# Have a conversation
response1 = conversation.predict(input="Hi, I'm working on a Python project.")
response2 = conversation.predict(input="Can you help me with error handling?")
response3 = conversation.predict(input="What did I mention I was working on?")

Vercel AI SDK Integration

Vercel AI SDK 0G Provider

Official Vercel AI SDK integration for 0G decentralized compute

Installation

npm install @ai-sdk/nebula

Basic Usage

import { createZG } from '@ai-sdk/0g';
import { generateText, streamText } from 'ai';

// Initialize 0G provider
const zg = createZG({
  providerAddress: '0xf07240Efa67755B5311bc75784a061eDB47165Dd', // llama-3.3-70b-instruct
  privateKey: 'your-private-key'
});

// Generate text
const { text } = await generateText({
  model: zg('llama-3.3-70b-instruct'),
  prompt: 'Explain the benefits of decentralized AI compute.'
});

console.log(text);

Streaming with React

'use client';

import { useChat } from 'ai/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: '/api/chat',
  });

  return (
    <div className="flex flex-col w-full max-w-md py-24 mx-auto stretch">
      {messages.map(m => (
        <div key={m.id} className="whitespace-pre-wrap">
          {m.role === 'user' ? 'User: ' : 'AI: '}
          {m.content}
        </div>
      ))}

      <form onSubmit={handleSubmit}>
        <input
          className="fixed bottom-0 w-full max-w-md p-2 mb-8 border border-gray-300 rounded shadow-xl"
          value={input}
          placeholder="Say something..."
          onChange={handleInputChange}
        />
      </form>
    </div>
  );
}

import { createZG } from '@ai-sdk/0g';
import { streamText } from 'ai';

const zg = createZG({
  providerAddress: '0xf07240Efa67755B5311bc75784a061eDB47165Dd',
  privateKey: process.env.ZG_PRIVATE_KEY!
});

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = await streamText({
    model: zg('llama-3.3-70b-instruct'),
    messages,
    system: 'You are a helpful AI assistant powered by decentralized compute.'
  });

  return result.toDataStreamResponse();
}

import { createZG } from '@ai-sdk/0g';
import { generateText, tool } from 'ai';
import { z } from 'zod';

const zg = createZG({
  providerAddress: '0x3feE5a4dd5FDb8a32dDA97Bed899830605dBD9D3', // deepseek-r1-70b for reasoning
  privateKey: 'your-private-key'
});

const { text } = await generateText({
  model: zg('deepseek-r1-70b'),
  prompt: 'What is the weather in San Francisco?',
  tools: {
    getWeather: tool({
      description: 'Get the current weather for a location',
      parameters: z.object({
        location: z.string().describe('The location to get weather for'),
      }),
      execute: async ({ location }) => {
        // Implement weather API call
        return { location, temperature: 72, condition: 'sunny' };
      },
    }),
  },
});

console.log(text);

OpenRouter Integration

OpenRouter 0G Provider

OpenRouter integration bringing 0G models to the OpenRouter ecosystem

Installation

npm install @openrouter/nebula-sdk-provider

Usage

import { createOpenRouter } from '@openrouter/ai-sdk-provider';
import { generateText } from 'ai';

// Configure OpenRouter with 0G provider
const openrouter = createOpenRouter({
  apiKey: process.env.OPENROUTER_API_KEY,
  providers: {
    '0g': {
      providerAddress: '0xf07240Efa67755B5311bc75784a061eDB47165Dd',
      privateKey: process.env.ZG_PRIVATE_KEY
    }
  }
});

// Use 0G models through OpenRouter
const { text } = await generateText({
  model: openrouter('0g/llama-3.3-70b-instruct'),
  prompt: 'Explain the advantages of decentralized AI infrastructure.'
});

console.log(text);

Model Routing

// Route between different 0G models based on task complexity
const routeModel = (taskComplexity: 'simple' | 'complex') => {
  return taskComplexity === 'complex' 
    ? openrouter('0g/deepseek-r1-70b')      // Complex reasoning
    : openrouter('0g/llama-3.3-70b-instruct'); // General tasks
};

// Simple task
const simpleResult = await generateText({
  model: routeModel('simple'),
  prompt: 'Write a brief summary of renewable energy.'
});

// Complex task
const complexResult = await generateText({
  model: routeModel('complex'),
  prompt: 'Analyze the economic implications of transitioning to renewable energy, considering supply chain, job market, and policy factors.'
});

LlamaIndex Integration

LlamaIndex 0G Provider

LlamaIndex integration for RAG applications with 0G decentralized compute

Installation

pip install llama-index-llms-nebula

Basic RAG Setup

from llama_index.llms.zg import ZG
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.settings import Settings

# Configure 0G LLM
Settings.llm = ZG(
    provider_address="0xf07240Efa67755B5311bc75784a061eDB47165Dd",  # llama-3.3-70b-instruct
    private_key="your-private-key",
    temperature=0.1
)

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

# Create index
index = VectorStoreIndex.from_documents(documents)

# Create query engine
query_engine = index.as_query_engine()

# Query the documents
response = query_engine.query("What are the key findings in the research papers?")
print(response)

Advanced RAG with 0G

from llama_index.core import StorageContext
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.embeddings.openai import OpenAIEmbedding
import chromadb

# Setup vector store
chroma_client = chromadb.PersistentClient()
chroma_collection = chroma_client.create_collection("documents")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Configure with 0G for reasoning-heavy tasks
Settings.llm = ZG(
    provider_address="0x3feE5a4dd5FDb8a32dDA97Bed899830605dBD9D3",  # deepseek-r1-70b
    private_key="your-private-key",
    temperature=0.2
)

# Create index with custom storage
index = VectorStoreIndex.from_documents(
    documents, 
    storage_context=storage_context
)

# Advanced querying
query_engine = index.as_query_engine(
    similarity_top_k=5,
    response_mode="tree_summarize"
)

response = query_engine.query(
    "Analyze the trends across all documents and provide strategic recommendations."
)

from llama_index.core.agent import ReActAgent
from llama_index.core.tools import QueryEngineTool, ToolMetadata

# Create multiple query engines for different document types
research_index = VectorStoreIndex.from_documents(research_docs)
financial_index = VectorStoreIndex.from_documents(financial_docs)

# Create tools
research_tool = QueryEngineTool(
    query_engine=research_index.as_query_engine(),
    metadata=ToolMetadata(
        name="research_query",
        description="Query research documents and papers"
    )
)

financial_tool = QueryEngineTool(
    query_engine=financial_index.as_query_engine(),
    metadata=ToolMetadata(
        name="financial_query", 
        description="Query financial reports and data"
    )
)

# Create agent with 0G LLM
agent = ReActAgent.from_tools(
    [research_tool, financial_tool],
    llm=ZG(
        provider_address="0x3feE5a4dd5FDb8a32dDA97Bed899830605dBD9D3",
        private_key="your-private-key"
    ),
    verbose=True
)

# Use agent for complex queries
response = agent.chat(
    "Compare the research findings with the financial performance data and provide insights."
)

from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.postprocessor import SimilarityPostprocessor

# Custom retriever setup
retriever = VectorIndexRetriever(
    index=index,
    similarity_top_k=10,
)

# Post-processing to filter results
postprocessor = SimilarityPostprocessor(similarity_cutoff=0.7)

# Custom query engine with 0G
query_engine = RetrieverQueryEngine(
    retriever=retriever,
    response_synthesizer=get_response_synthesizer(
        llm=ZG(
            provider_address="0xf07240Efa67755B5311bc75784a061eDB47165Dd",
            private_key="your-private-key",
            temperature=0.3
        )
    ),
    node_postprocessors=[postprocessor],
)

# Query with custom pipeline
response = query_engine.query("What are the implications of the latest research?")

Integration Benefits

Decentralized Advantages

No Vendor Lock-in

Use familiar frameworks while avoiding dependency on centralized AI providers

Cost Efficiency

Competitive pricing through decentralized compute marketplace

Censorship Resistance

Decentralized network ensures availability and resistance to censorship

Privacy & Security

TEE (Trusted Execution Environment) verification for secure computation

Framework-Specific Benefits

Framework	Key Benefits	Use Cases
LangChain	Seamless chain/agent integration, extensive ecosystem	Complex workflows, multi-step reasoning
Vercel AI SDK	React streaming, edge deployment, type safety	Real-time chat, web applications
OpenRouter	Model routing, fallback strategies, unified API	Production applications, model comparison
LlamaIndex	RAG optimization, document processing, vector search	Knowledge bases, document analysis

Getting Started

Choose your framework based on your use case and existing stack
Install the appropriate 0G provider using the installation commands above
Configure with your private key and preferred model provider address
Start building with decentralized AI compute!

Migration Guide

From OpenAI to 0G

import OpenAI from 'openai';

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

const completion = await openai.chat.completions.create({
  messages: [{ role: "user", content: "Hello!" }],
  model: "llama-3.3-70b-instruct",
});

import { createZG } from '@ai-sdk/0g';
import { generateText } from 'ai';

const zg = createZG({
  providerAddress: '0xf07240Efa67755B5311bc75784a061eDB47165Dd',
  privateKey: process.env.ZG_PRIVATE_KEY
});

const { text } = await generateText({
  model: zg('llama-3.3-70b-instruct'),
  messages: [{ role: "user", content: "Hello!" }]
});

From Anthropic to 0G

import anthropic

client = anthropic.Anthropic(
    api_key="your-api-key"
)

message = client.messages.create(
    model="claude-3-sonnet-20240229",
    max_tokens=1000,
    messages=[{"role": "user", "content": "Hello!"}]
)

from langchain_0g import ZGChat
from langchain.schema import HumanMessage

llm = ZGChat(
    provider_address="0x3feE5a4dd5FDb8a32dDA97Bed899830605dBD9D3",  # deepseek-r1-70b
    private_key="your-private-key",
    max_tokens=1000
)

response = llm.invoke([HumanMessage(content="Hello!")])

Community & Support

GitHub Discussions: Join framework-specific discussions in each integration repository
Discord: Connect with the 0G community for integration support
Documentation: Comprehensive guides for each framework integration
Examples: Production-ready examples in each integration repository

Ready to integrate 0G with your favorite framework? Check out the specific integration repositories linked above for detailed setup guides and examples!

​Framework Integrations

​Available Providers

LangChain

Vercel AI SDK

OpenRouter

LlamaIndex

​Integration Status

​Supported Models

​LangChain Integration

LangChain 0G Provider

​Installation

​Basic Usage

​Advanced LangChain Features

​Vercel AI SDK Integration

Vercel AI SDK 0G Provider

​Installation

​Basic Usage

​Streaming with React

​OpenRouter Integration

OpenRouter 0G Provider

​Installation

​Usage

​Model Routing

​LlamaIndex Integration

LlamaIndex 0G Provider

​Installation

​Basic RAG Setup

​Advanced RAG with 0G

​Integration Benefits

​Decentralized Advantages

No Vendor Lock-in

Cost Efficiency

Censorship Resistance

Privacy & Security

​Framework-Specific Benefits

​Getting Started

​Migration Guide

​From OpenAI to 0G

​From Anthropic to 0G

​Community & Support

Framework Integrations

Available Providers

Integration Status

Supported Models

LangChain Integration

Installation

Basic Usage

Advanced LangChain Features

Vercel AI SDK Integration

Installation

Basic Usage

Streaming with React

OpenRouter Integration

Installation

Usage

Model Routing

LlamaIndex Integration

Installation

Basic RAG Setup

Advanced RAG with 0G

Integration Benefits

Decentralized Advantages

Framework-Specific Benefits

Getting Started

Migration Guide

From OpenAI to 0G

From Anthropic to 0G

Community & Support