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 Muster für AI-Anwendungen. Dokumente werden hochgeladen, in Chunks unterteilt, Embeddings erstellt, relevante Fragmente gesucht und eine Antwort mit Kontext generiert.

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="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. Dokumente laden und indizieren
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. Abfrage
result = qa.invoke("Worum geht es in diesem Dokument?")
print(result["result"])

Kosten: Eine RAG-Pipeline-Abfrage (Retrieval + Generation) verwendet ~2-5K LLM-Tokens. Über Gonka sind das $0.00001-0.000024. Über OpenAI — $0.005-0.05. Der Unterschied beträgt 1.300x.

Für Produktionssysteme, die Tausende von Anfragen pro Tag verarbeiten, belaufen sich die Einsparungen auf Zehntausende von 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.