स्थानीय या होस्ट किया गया: उस बाधा के आधार पर चुनें जो आपको सबसे ज़्यादा रोकती है
स्थानीय मॉडल के साथ LangChain खोजने वाले आमतौर पर तीन चीज़ों में से एक चाहते हैं: गोपनीयता, प्रति-टोकन बिल नहीं, या एक वेंडर से स्वतंत्रता। आपकी मशीन पर एक मॉडल, Ollama या llama.cpp जैसे टूल द्वारा प्रदान किया जाना, सभी तीन प्रदान करता है यदि आपके पास हार्डवेयर है जो इसे उपयोगी गति पर चला सकता है। ट्रेड ऑफ़ सेटअप समय, मेमोरी सीमाएँ और आपके पास मौजूद GPU या CPU की गति है।
एक होस्ट किया गया एंडपॉइंट इन चीज़ों के बदले एक छोटी उपयोग लागत लेता है। आप नेटवर्क के माध्यम से प्रॉम्प्ट भेजते हैं, और मॉडल किसी अन्य के हार्डवेयर पर चलता है। यहाँ इसका मतलब एक ओपन-वेट मॉडल है, जिसे वयस्कों के वैध उपयोग के लिए सामग्री अस्वीकृति के बिना उत्तर देने के लिए ट्यून किया गया है, और जो OpenAI-संगत API के माध्यम से उपलब्ध कराया जाता है। प्रॉम्प्ट ट्रेनिंग के लिए उपयोग नहीं किए जाते हैं, लेकिन वे आपकी मशीन से बाहर चले जाते हैं, इसलिए यदि आपका नियम यह है कि डेटा कभी भी बाहर नहीं जाना चाहिए, तो होस्ट की गई सेवा गलत विकल्प है।
LangChain डेवलपर के लिए उपयोगी हिस्सा यह है कि कोड में बहुत कम अंतर है। स्थानीय सर्वर जैसे Ollama और llama.cpp OpenAI-शैली के एंडपॉइंट उपलब्ध कराते हैं, और होस्ट किया गया एंडपॉइंट वही प्रोटोकॉल बोलता है। यदि आप अपना ऐप ChatOpenAI के साथ, कॉन्फ़िगर करने योग्य बेस URL रखते हुए, लिखते हैं, तो आप स्थानीय रूप से विकसित कर सकते हैं और एक एनवायरनमेंट वेरिएबल के साथ होस्ट किए गए मॉडल पर स्विच कर सकते हैं। यह आपको एक व्यावहारिक हाइब्रिड देता है: एक छोटे स्थानीय मॉडल पर इटरेट करें, और बड़े मॉडल के व्यवहार का उपयोग करें बिना GPU को स्वयं रखे।
ChatOpenAI को एंडपॉइंट से कनेक्ट करें
इंटीग्रेशन पैकेज इंस्टॉल करें, फिर उन तीन सेटिंग्स के साथ मॉडल ऑब्जेक्ट बनाएं जो मायने रखती हैं।
pip install langchain-openai langchain-core
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmproxyapi.com/v1",
api_key=os.environ["LLMPROXY_API_KEY"],
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
यदि यह चलता है, तो बाकी सब कुछ उसी तरह काम करता है। अपनी कुंजी API कुंजी पेज से प्राप्त करें; नए उपयोगकर्ता साइन अप करने के बाद वहाँ एक क्लिक के साथ $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं, बिना कार्ड के। बेस URL को कोड में स्पष्ट रूप से पास करें, एनवायरनमेंट वेरिएबल पर निर्भर रहने के बजाय, क्योंकि अलग-अलग लाइब्रेरी वर्ज़न अलग-अलग वेरिएबल नाम पढ़ते हैं और डिफ़ॉल्ट OpenAI होस्ट पर चुपचाप फॉलबैक आपकी कुंजी को गलत जगह भेज सकता है।
मॉडल का नाम वह जगह है जहां लोग फंस जाते हैं। यहाँ एकमात्र ID uncensored है। llama3 या gpt-4o जैसा कोई नाम पहचाना नहीं जाएगा।
एक प्रॉम्प्ट टेम्पलेट के साथ चेन
प्रॉम्प्ट, मॉडल और आउटपुट पार्सर का मानक पाइपलाइन अपरिवर्तित चलता है। यह उदाहरण किसी चुने गए टोन में टेक्स्ट को सारांशित करता है।
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You are a writing assistant. Answer in a {tone} tone."),
("human", "Summarize in two sentences:\n\n{text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "dry", "text": "Long article text goes here..."}))
अनेक इनपुट के लिए, batch का उपयोग करें और समानांतरता को सीमित करें। एक पूर्ण कुंजी 8 समानांतर अनुरोधों और प्रति मिनट 300 अनुरोधों की अनुमति देती है, इसलिए सेटिंग को 8 या उससे कम रखें:
results = chain.batch(
[{"tone": "dry", "text": t} for t in documents],
config={"max_concurrency": 6},
)
एक ट्रायल कुंजी केवल 2 समानांतर अनुरोधों और प्रति मिनट 60 की अनुमति देती है, इसलिए परीक्षण के दौरान max_concurrency को 2 रखें।
स्ट्रीमिंग
API Server-Sent Events के माध्यम से stream करती है, और LangChain इसे stream के माध्यम से उपलब्ध कराता है। इसका उपयोग उस चैट इंटरफेस के लिए करें जहां एक व्यक्ति उत्तर बनते हुए देखता है।
for chunk in llm.stream("Write a short scene set in a lighthouse."):
print(chunk.content, end="", flush=True)
एक व्यावहारिक विवरण: एक स्ट्रीम किया गया अनुरोध अपना कॉन्करेंसी स्लॉट तब तक रखता है जब तक स्ट्रीम समाप्त न हो जाए। यदि आपका UI आधे रास्ते में स्ट्रीम छोड़ देता है, तो सुनिश्चित करें कि जनरेटर बंद हो, वरना आपकी कॉन्करेंसी क्षमता कम हो जाएगी। एसिंक्रोनस कोड उसी तरह astream का उपयोग करता है।
टूल्स और एजेंट्स
टूल कॉलिंग समर्थित है: API tools और tool_choice स्वीकार करता है, tool_calls स्ट्रीम करता है और परिणामों को role: "tool" संदेशों के रूप में लेता है। LangChain इसे bind_tools में लपेटता है।
from langchain_core.tools import tool
@tool
def dice(sides: int) -> int:
"Roll a die with the given number of sides."
import random
return random.randint(1, sides)
llm_tools = llm.bind_tools([dice])
msg = llm_tools.invoke("Roll a twenty-sided die for the goblin attack.")
print(msg.tool_calls)
परिणाम उन कॉल्स की सूची देता है जो मॉडल करना चाहता है, नामों और तर्कों के साथ। उन्हें चलाएं, परिणामों को टूल संदेशों के रूप में जोड़ें और मॉडल को फिर से कॉल करें, या LangGraph जैसे एजेंट फ्रेमवर्क को वह लूप चलने दें। एजेंट्स प्रति उपयोगकर्ता अनुरोध में कई कॉल करते हैं, इसलिए वे साधारण चेन की तुलना में प्रति मिनट की सीमा जल्दी छू लेते हैं। कॉन्करेंसी स्तर चुनने से पहले प्रति रन कॉल्स की गिनती करें।
प्रॉम्प्ट और कंप्लीशन के लिए कॉन्टेक्स्ट विंडो 100,000 टोकन का है, जो कॉन्वर्सेशन मेमोरी के लिए पर्याप्त है। फिर भी, पुराने टर्न्स को काटें: आप हर कॉल पर पूरी हिस्ट्री के लिए भुगतान करते हैं, $0.15 प्रति 1M इनपुट टोकन पर।
JSON आउटपुट
JSON मोड response_format के माध्यम से उपलब्ध है। LangChain में आप इसे model_kwargs के साथ पास कर सकते हैं या JSON मोड में स्ट्रक्चर्ड आउटपुट हेल्पर का उपयोग कर सकते हैं, और अपने प्रॉम्प्ट में फ़ील्ड्स को वर्णित कर सकते हैं।
from pydantic import BaseModel
class Character(BaseModel):
name: str
role: str
secret: str
structured = llm.with_structured_output(Character, method="json_mode")
out = structured.invoke(
"Invent a character for a mystery story. Reply in JSON with keys name, role, secret."
)
print(out)
method="json_mode" के साथ, प्रॉम्प्ट को मॉडल को कौन सी कुंजियाँ बनानी हैं, यह बताना चाहिए; Pydantic क्लास फिर पार्स किए गए परिणाम को सत्यापित करती है। दुर्लभ खराब प्रतिक्रिया के लिए इसके आसपास एक पुनः प्रयास रखें।
जो समर्थित नहीं है
LangChain की दो बुनियादी सुविधाओं को एक अलग स्रोत की आवश्यकता है। API में कोई एम्बेडिंग एंडपॉइंट नहीं है, इसलिए यहाँ इशारा करने वाला OpenAIEmbeddings विफल हो जाएगा। अपने दस्तावेज़ों पर पुनर्प्राप्ति के लिए, एक लोकल एम्बेडिंग मॉडल या एक अन्य एम्बेडिंग प्रदाता का उपयोग करें, और केवल चैट चरण के लिए इस एंडपॉइंट का उपयोग करें। इसमें कोई इमेज इनपुट या जनरेशन, कोई ऑडियो और कोई फाइन-ट्यूनिंग भी नहीं है, इसलिए विजन चेन और मल्टीमोडल लोडर बाहर हैं।
त्रुटि हैंडलिंग मुख्य रूप से 429 प्रतिक्रियाओं के बारे में है। कोड rate_limited का अर्थ है कि आपने प्रति-मिनट की सीमा पार कर दी, concurrency का अर्थ है बहुत सारे समानांतर अनुरोध, और Retry-After: 5 के साथ 429 अस्थायी ओवरलोड को दर्शाता है। ChatOpenAI पर max_retries सेट करें ताकि क्लाइंट प्रतीक्षा और पुनः प्रयास कर सके। विफल और अस्वीकृत अनुरोधों के लिए शुल्क नहीं लगाया जाता।
प्रतिक्रिया शीर्षक निगरानी में मदद करते हैं: X-Balance-USD आपका शेष क्रेडिट दिखाता है और X-Request-Id एक अनुरोध को सहायता के लिए पहचानता है।
एक वेरिएबल के साथ लोकल और होस्टेड के बीच स्विच करना
यदि आप हाइब्रिड सेटअप चाहते हैं, तो तीन सेटिंग्स को एनवायरनमेंट वेरिएबल्स में डालें और एक फंक्शन में मॉडल बनाएं। आपकी चेन उस फंक्शन को इम्पोर्ट करती है और कभी भी वेंडर का जिक्र नहीं करती।
import os
from langchain_openai import ChatOpenAI
def make_llm():
if os.environ.get("LLM_MODE") == "local":
return ChatOpenAI(
model=os.environ["LOCAL_MODEL"],
base_url="http://localhost:11434/v1",
api_key="not-needed",
)
return ChatOpenAI(
model="uncensored",
base_url="https://api.llmproxyapi.com/v1",
api_key=os.environ["LLMPROXY_API_KEY"],
)
लोकल शाखा डिफ़ॉल्ट पोर्ट पर एक Ollama सर्वर मानती है, जो /v1 के तहत OpenAI-शैली का रूट उपलब्ध कराता है; सही पता और मॉडल नाम के लिए अपने सर्वर की दस्तावेज़ जांचें। व्यवहार मॉडल के बीच अलग होगा, इसलिए स्विच करने के बाद अपने प्रॉम्प्ट को फिर से चलाएं। एक मॉडल की आदतों के लिए ट्यून्ड प्रॉम्प्ट दूसरे पर अलग व्यवहार कर सकता है, और मॉडल के साथ टूल कॉलिंग की गुणवत्ता भिन्न होती है, इसलिए पहले उन पथों का परीक्षण करें।
एक समझदारी भरा वर्कफ़्लो यह है कि जब आपके पास कोई GPU खाली न हो तो होस्टेड मॉडल के खिलाफ प्रॉम्प्ट डेवलप करें, फिर तय करें कि ऐप के कौन से हिस्से आपकी मशीन पर ही रहने चाहिए। संवेदनशील दस्तावेज़ लोकल शाखा का उपयोग कर सकते हैं, और सार्वजनिक रचनात्मक सुविधाएं होस्टेड का उपयोग कर सकती हैं।
लागत और अगले कदम
मूल्य निर्धारण $0.15 प्रति 1M इनपुट टोकन और $0.50 प्रति 1M आउटपुट टोकन के लिए है, प्रीपेड क्रेडिट से, कोई सदस्यता नहीं। 2,000 इनपुट टोकन और 500 आउटपुट टोकन वाले एक चेन अनुरोध की लागत 2,000 x $0.15 / 1M + 500 x $0.50 / 1M = $0.0003 + $0.00025 = $0.00055 है। ऐसे हज़ार अनुरोधों की लागत $0.55 है। क्रिप्टो (TRC20 पर USDT, Base पर USDC) से $20 से $500 तक टॉप-अप चलते हैं, $50 से 5%, $100 से 10% और $200 से 15% बोनस के साथ। विवरण मूल्य निर्धारण पेज पर हैं।
उसी API के सादे HTTP दृश्य के लिए क्विकस्टार्ट पढ़ें। साइट पर पे-एज़-यू-गो सेवा का एक छोटा अवलोकन भी है।
