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

Minimalbeispiel – LangChain mit Gonka verbinden:

from langchain_openai import ChatOpenAI

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

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

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

Abhängigkeiten installieren:

pip install langchain langchain-openai

Empfehlung: Geben Sie explizit max_tokens=8192 an – das ist die Ausgabeobergrenze über das JoinGonka Gateway für MiniMax M2.7 und GLM-5.3 Flash (bei DeepSeek V4 Flash – bis zu 32768). Das Kontextfenster beträgt 200K Token bei MiniMax M2.7 (380K bei DeepSeek V4 Flash, 390K bei GLM-5.3 Flash) – berücksichtigen Sie dies bei der Einstellung von chunk_size in RAG-Pipelines.

RAG (Retrieval-Augmented Generation) ist das beliebteste Muster für KI-Anwendungen. Man lädt Dokumente hoch, zerlegt sie in Chunks, erstellt Embeddings, sucht die relevanten Fragmente und generiert 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. Load and index documents
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Vector store (local, free)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

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

# 5. Query
result = qa.invoke("What is this document about?")
print(result["result"])

Kosten: Eine Anfrage an die RAG-Pipeline (Retrieval + Generation) verbraucht etwa 2–5K LLM-Token. Über Gonka kostet das $0.00001–0.000024. Über OpenAI $0.005–0.05. Der Unterschied liegt bei Faktor 1.300.

Für Produktionssysteme, die täglich Tausende Anfragen verarbeiten, summiert sich die Ersparnis auf mehrere zehntausend Dollar pro Monat.

Mit LangChain lassen sich Agenten mit Tools erstellen. Die Modelle im Netzwerk unterstützen natives Tool Calling — die Agenten arbeiten zuverlässig, ganz ohne Parsing 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
)

@tool
def calculator(expression: str) -> str:
    """Evaluates a math expression."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Searches the web for information."""
    return f"Search results for: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("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": "What is 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 etwa $0.00005. Über OpenAI $0.01–0.05. Bei Systemen mit Tausenden Nutzern bedeutet das einen Unterschied von mehreren zehntausend Dollar.