LangChain + Gonka AI – KI-Anwendungen für wenige Cent

Ein minimales Beispiel – Anbindung von LangChain an Gonka:

from langchain_openai import ChatOpenAI

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

response = llm.invoke("Erkläre, was RAG ist")
print(response.content)

Das ist alles. Drei Zeilen – und Ihr LangChain-Projekt läuft über das dezentrale Gonka-Netzwerk für ein paar Cent.

Abhängigkeiten installieren:

pip install langchain langchain-openai

Empfehlung: Geben Sie explizit max_tokens=2048 an – dies ist das Maximum über JoinGonka Gateway. Das Kontextfenster von Qwen3-235B beträgt 128K Token – berücksichtigen Sie dies bei der Einstellung von chunk_size in RAG-Pipelines.

RAG (Retrieval-Augmented Generation) – das beliebteste Muster für KI-Anwendungen. Sie laden Dokumente hoch, teilen sie in Chunks auf, erstellen Embeddings, suchen nach relevanten Fragmenten und generieren eine Antwort mit Kontext.

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 über Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-Ihr-Schlüssel",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    streaming=True,
)

# 2. Dokumente laden und indexieren
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Vektorspeicher (lokal, kostenlos)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

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

# 5. Anfrage
result = qa.invoke("Worum geht es in diesem Dokument?")
print(result["result"])

Kosten: Eine RAG-Pipeline-Anfrage (Retrieval + Generation) verbraucht ~2-5K LLM-Tokens. Über Gonka sind das 0,000002-0,000005 $. Über OpenAI – 0,005-0,05 $. Der Unterschied beträgt das 10.000-fache.

Für Produktionssysteme, die Tausende von Anfragen pro Tag verarbeiten, belaufen sich die Einsparungen auf Zehntausende von Dollar pro Monat.

LangChain ermöglicht es, Agenten mit Tools zu erstellen. Qwen3-235B unterstützt natives Tool Calling – Agenten arbeiten zuverlässig, ohne das Parsen von Textantworten.

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-Ihr-Schlüssel",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@tool
def calculator(expression: str) -> str:
    """Berechnet einen mathematischen Ausdruck."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Sucht Informationen im Internet."""
    return f"Suchergebnisse für: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein hilfreicher Assistent."),
    ("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": "Wie viel ist 2**10 * 3.14?"})
print(result["output"])

Der Agent ruft calculator auf, erhält das Ergebnis und bildet die Antwort. Der gesamte Zyklus kostet über Gonka etwa 0,00001 $. Über OpenAI sind es 0,01-0,05 $. Für Systeme mit Tausenden von Benutzern ist dies ein Unterschied von Zehntausenden von Dollar.