LangChain + Gonka AI — aplikacje AI za grosze

Minimalny przykład — podłączenie LangChain do Gonka:

from langchain_openai import ChatOpenAI

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

response = llm.invoke("Explain what RAG is")
print(response.content)

To wszystko. Trzy linijki — i Twój projekt LangChain działa przez zdecentralizowaną sieć Gonka za grosze.

Instalacja zależności:

pip install langchain langchain-openai

Zalecenie: jawnie określ max_tokens=2048 — to maksimum przez JoinGonka Gateway. Okno kontekstowe Qwen3-235B — 128K tokenów — weź to pod uwagę przy konfiguracji chunk_size w potokach RAG.

RAG (Retrieval-Augmented Generation) — najpopularniejszy wzorzec aplikacji AI. Ładujesz dokumenty, dzielisz na fragmenty, tworzysz osadzenia, wyszukujesz odpowiednie fragmenty i generujesz odpowiedź z kontekstem.

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 przez Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-twój-klucz",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    streaming=True,
)

# 2. Ładowanie i indeksowanie dokumentów
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Magazyn wektorowy (lokalny, bezpłatny)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. Łańcuch RAG
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. Zapytanie
result = qa.invoke("O czym jest ten dokument?")
print(result["result"])

Koszt: jedno zapytanie potoku RAG (pobieranie + generowanie) zużywa ~2–5K tokenów LLM. Przez Gonka to 0,000002–0,000005 USD. Przez OpenAI — 0,005–0,05 USD. Różnica — 10 000x.

Dla systemów produkcyjnych, przetwarzających tysiące zapytań dziennie, oszczędności wynoszą dziesiątki tysięcy dolarów miesięcznie.

LangChain umożliwia tworzenie agentów z narzędziami (tools). Qwen3-235B obsługuje natywne wywoływanie narzędzi — agenci działają niezawodnie, bez parsowania odpowiedzi tekstowych.

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-twój-klucz",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@tool
def calculator(expression: str) -> str:
    """Oblicza wyrażenie matematyczne."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Wyszukuje informacje w internecie."""
    return f"Wyniki wyszukiwania dla: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Jesteś pomocnym asystentem."),
    ("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": "Ile wynosi 2**10 * 3.14?"})
print(result["output"])

Agent wywołuje calculator, otrzymuje wynik i formułuje odpowiedź. Cały cykl kosztuje ~0,00001 USD przez Gonka. Przez OpenAI — 0,01–0,05 USD. Dla systemów z tysiącami użytkowników to różnica dziesiątek tysięcy dolarów.