LangChain + Gonka AI — Applicazioni AI a un costo minimo

Esempio minimo – connessione di LangChain a Gonka:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-la-tua-chiave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

response = llm.invoke("Spiega cos'è RAG")
print(response.content)

È tutto. Tre righe – e il tuo progetto LangChain funziona tramite la rete decentralizzata Gonka per pochi centesimi.

Installazione delle dipendenze:

pip install langchain langchain-openai

Raccomandazione: specifica esplicitamente max_tokens=2048 – è il massimo tramite JoinGonka Gateway. La finestra di contesto di Qwen3-235B è 128K token – tienilo presente quando configuri chunk_size nelle pipeline RAG.

RAG (Retrieval-Augmented Generation) — il modello più popolare di applicazioni AI. Carica documenti, dividili in chunk, crea embeddings, cerca frammenti pertinenti e genera una risposta con contesto.

from langchain_openai import ChatOpenAI
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.document_loaders import TextLoader

# 1. LLM tramite Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-la-tua-chiave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    streaming=True,
)

# 2. Caricamento e indicizzazione dei documenti
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Archivio vettoriale (locale, gratuito)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. Catena RAG
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. Query
result = qa.invoke("Di cosa tratta questo documento?")
print(result["result"])

Costo: una singola query della pipeline RAG (retrieval + generation) utilizza ~2-5K token LLM. Tramite Gonka questo è $0.000002-0.000005. Tramite OpenAI — $0.005-0.05. La differenza è di 10,000x.

Per i sistemi di produzione che elaborano migliaia di richieste al giorno, il risparmio ammonta a decine di migliaia di dollari al mese.

LangChain permette di creare agenti con strumenti (tools). Qwen3-235B supporta il tool calling nativo — gli agenti funzionano in modo affidabile, senza parsificare risposte testuali.

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-la-tua-chiave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@tool
def calculator(expression: str) -> str:
    """Calcola un'espressione matematica."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Cerca informazioni su internet."""
    return f"Risultati di ricerca per: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Sei un assistente utile."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_openai_tools_agent(llm, [calculator, search_web], prompt)
executor = AgentExecutor(agent=agent, tools=[calculator, search_web])

result = executor.invoke({"input": "Quanto fa 2**10 * 3.14?"})
print(result["output"])

L'agente chiama calculator, ottiene il risultato e forma la risposta. L'intero ciclo costa ~$0.00001 tramite Gonka. Tramite OpenAI — $0.01-0.05. Per sistemi con migliaia di utenti, questa è una differenza di decine di migliaia di dollari.