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

Ein Minimalbeispiel – Verbindung von LangChain mit Gonka:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-Ihr-Schlüssel",
    model="MiniMaxAI/MiniMax-M2.7",
)

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

Das ist alles. Drei Zeilen – und Ihr LangChain-Projekt läuft kostengünstig über das dezentrale Gonka-Netzwerk.

Abhängigkeiten installieren:

pip install langchain langchain-openai

Empfehlung: Geben Sie explizit max_tokens=8192 an – dies ist die Obergrenze für Ausgaben über das JoinGonka Gateway für alle Modelle im Netzwerk. Das Kontextfenster der Netzwerk-Modelle beträgt 200K Token – berücksichtigen Sie dies bei der Einstellung von chunk_size in RAG-Pipelines.

RAG (Retrieval-Augmented Generation) ist das beliebteste Pattern für KI-Anwendungen. Sie laden Dokumente hoch, unterteilen sie in Chunks, erstellen Embeddings, suchen relevante Fragmente 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 via Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-ваш-ключ",
    model="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. Laden und Indizieren von Dokumenten
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-Chain
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. Abfrage
result = qa.invoke("Worüber handelt dieses Dokument?")
print(result["result"])

Kosten: Eine Anfrage einer RAG-Pipeline (Retrieval + Generation) verbraucht ~2-5K LLM-Token. Über Gonka sind das $0.00001-0.000024. Über OpenAI sind es $0.005-0.05. Ein Unterschied von 2.000x.

Für Produktionssysteme, die tausende Anfragen pro Tag bearbeiten, summieren sich die Einsparungen auf zehntausende Dollar pro Monat.

LangChain ermöglicht die Erstellung von Agenten mit Tools. Kimi K2.6 unterstützt natives Tool Calling — die Agenten arbeiten zuverlässig, ohne dass Textantworten aufwendig geparst werden müssen.

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-ваш-ключ",
    model="MiniMaxAI/MiniMax-M2.7",
)

@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 formuliert die Antwort. Der gesamte Zyklus kostet über Gonka ~$0.00005. Über OpenAI — $0.01-0.05. Für Systeme mit Tausenden von Benutzern ist das ein Unterschied von zehntausenden Dollar.