Python में Ollama API, फिर एक होस्टेड एंडपॉइंट

Python क्लाइंट सेट करें

सबसे पहले Ollama को स्थापित करें, उसे चलाएँ और टर्मिनल से एक मॉडल खींचें: ollama pull llama3। सर्वर http://localhost:11434 पर सुनता है। फिर वर्चुअल एन्वायरनमेंट में पायथन पैकेज स्थापित करें:

Copypython -m venv .venv
source .venv/bin/activate
pip install ollama openai

ollama पैकेज /api के तहत Ollama के नेटिव रूट्स से बात करता है। openai पैकेज इस ट्यूटोरियल के दूसरे हिस्से के लिए है, जहाँ टारगेट एक होस्टेड एंडपॉइंट है। यदि कोडिंग से पहले आपको एक विजुअल टूल पसंद है, तो GUI के साथ Ollama का उपयोग पर नोट्स देखें।

टर्मिनल में ollama list चलाकर इंस्टॉलेशन की जाँच करें। यदि आपका मॉडल वहाँ दिखाई देता है, तो पायथन उसे ढूँढ लेगा। यदि बाद में कनेक्शन एरर आता है, तो संभवतः सर्वर चालू नहीं है।

आपका पहला चैट कॉल

यह ollama api पायथन बेसिक्स एक स्निपेट में है: एक सिस्टम संदेश, एक यूज़र संदेश और दो विकल्प।

Copyimport ollama

resp = ollama.chat(
    model="llama3",
    messages=[
        {"role": "system", "content": "Answer in one short paragraph."},
        {"role": "user", "content": "What is a context window?"},
    ],
    options={"temperature": 0.4, "num_ctx": 8192},
)
print(resp["message"]["content"])

प्रतिक्रिया एक डिक्शनरी-जैसा ऑब्जेक्ट है; पाठ message.content में होता है। options में आप जनरेशन पैरामीटर सेट कर सकते हैं। temperature यादृच्छिकता को नियंत्रित करता है और num_ctx उस कॉल के लिए कॉन्टेक्स्ट लंबाई सेट करता है। Ollama कॉन्टेक्स्ट को काफी छोटा रखता है जब तक आप इसे बढ़ाएं नहीं, जिससे उन लोगों को हैरानी होती है जो लंबे दस्तावेज पेस्ट करते हैं और उत्तरों में शुरुआत को अनदेखा करते हुए देखते हैं।

मल्टी-टर्न चैट के लिए, संदेशों की एक लिस्ट रखें और हर रिप्लाई को खुद ऐपेंड करें। Ollama, ज़्यादातर चैट APIs की तरह, कॉल्स के बीच स्टेटलेस है।

स्ट्रीमिंग प्रतिक्रियाएं

स्ट्रीमिंग के बिना आप पूरे जवाब का इंतज़ार करते हैं। stream=True के साथ फ़ंक्शन एक जनरेटर लौटाता है और आप हिस्सों को प्रिंट करते हैं जैसे ही वे आते हैं:

Copyimport ollama

for part in ollama.chat(
    model="llama3",
    messages=[{"role": "user", "content": "Explain recursion with a cooking analogy."}],
    stream=True,
):
    print(part["message"]["content"], end="", flush=True)

हर पार्ट में एक छोटा message.content होता है। आखिरी पार्ट में done true सेट होता है और टाइमिंग व टोकन काउंट शामिल होता है। वेब ऐप्स के लिए, सर्वर-सेंट इवेंट्स या वेबसोकेट के ज़रिए इन हिस्सों को ब्राउज़र पर फॉरवर्ड करें।

वे एरर जो आप वास्तव में देखेंगे

दो विफलताएं अधिकांश शुरुआती समस्याओं को कवर करती हैं।

Copyimport ollama

try:
    ollama.chat(model="llama3", messages=[{"role": "user", "content": "hi"}])
except ollama.ResponseError as exc:
    if exc.status_code == 404:
        print("Model missing. Run: ollama pull llama3")
    else:
        raise
except ConnectionError:
    print("Cannot reach Ollama. Is the server running on port 11434?")

ResponseError से 404 का मतलब है कि मॉडल का नाम आपके द्वारा खींचे गए किसी मॉडल से मेल नहीं खाता। नामों में टैग्स शामिल होते हैं, इसलिए llama3 और llama3:70b अलग-अलग मॉडल हैं। एक कनेक्शन एरर का मतलब है कि सर्वर चालू नहीं है, या आप एक कंटेनर के अंदर हैं जहाँ localhost होस्ट की जगह कंटेनर की ओर इशारा करता है। उस स्थिति में सही होस्ट के साथ एक क्लाइंट पास करें: ollama.Client(host="http://host.docker.internal:11434")।

और पैटर्न आम Ollama API गलतियों में एकत्रित किए गए हैं।

समान प्रोग्राम, होस्टेड एंडपॉइंट

लोकल मॉडल्स आपकी मेमोरी और स्पीड से सीमित होते हैं। जब एक स्क्रिप्ट को सर्वर पर चलाना हो, कई समानांतर जॉब हैंडल करने हों, या एक बड़ी विंडो का उपयोग करना हो, तो एक होस्टेड एंडपॉइंट आसान होता है। ट्रिक यह है कि प्रोग्राम को OpenAI SDK के खिलाफ लिखें और बेस यूआरएल, की और मॉडल को कॉन्फ़िगरेशन मानें:

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.ollamansfw.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def ask(prompt, history=None):
    messages = (history or []) + [{"role": "user", "content": prompt}]
    out = ""
    for chunk in client.chat.completions.create(model=MODEL, messages=messages, stream=True):
        if chunk.choices and chunk.choices[0].delta.content:
            piece = chunk.choices[0].delta.content
            out += piece
            print(piece, end="", flush=True)
    return out

ask("Explain recursion with a cooking analogy.")

लोकल Ollama के लिए, LLM_BASE_URL=http://localhost:11434/v1, LLM_API_KEY=ollama (वहां किसी भी गैर-खाली स्ट्रिंग को स्वीकार किया जाता है) और LLM_MODEL=llama3 सेट करें। होस्टेड API के लिए, ऊपर दिए गए डिफ़ॉल्ट्स, अपनी असली कुंजी और मॉडल uncensored का उपयोग करें। कोड में कुछ और बदलाव नहीं होता।

API कुंजी पेज पर एक कुंजी प्राप्त करें। नए खातों में एक क्लिक में $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं, बिना भुगतान के, जो 7 दिनों के लिए मान्य है। मॉडल एक स्वतंत्र प्रदाता से एक ओपन-वेट मॉडल है, जिसे वयस्कों के वैध उपयोग के लिए सामग्री अस्वीकृतियों के बिना उत्तर देने के लिए ट्यून्ड किया गया है। यह केवल टेक्स्ट है और किसी बड़े लैब की आधिकारिक API नहीं है।

एक साथ कई प्रॉम्प्ट चलाएँ

स्थानीय मॉडल एक मशीन पर आमतौर पर एक समय में एक अनुरोध संभालता है, इसलिए लूप क्रमिक होते हैं। एक होस्टेड एंडपॉइंट समवर्तिता की अनुमति देता है, जिससे बैच कार्य बहुत तेज़ हो जाता है। वर्कर काउंट को अपनी कुंजी की सीमा के नीचे रखें: पूर्ण कुंजी के लिए 8 समानांतर अनुरोध, ट्रायल कुंजी के लिए 2।

Copyfrom concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

client = OpenAI(base_url="https://api.ollamansfw.com/v1", api_key="YOUR_KEY")

def summarize(text):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarize in one line: " + text}],
        max_tokens=60,
    )
    return r.choices[0].message.content

docs = ["first text", "second text", "third text"]
with ThreadPoolExecutor(max_workers=6) as pool:
    results = list(pool.map(summarize, docs))
print(results)

छह वर्कर 8 की सीमा से नीचे रिजर्व छोड़ते हैं। यदि एक वर्कर को 429 मिलता है, तो OpenAI SDK डिफ़ॉल्ट रूप से कुछ बार पुनः प्रयास करता है, लेकिन लंबे रन के लिए अपना बैकऑफ़ (प्रतीक्षा अंतराल) जोड़ें। यह भी याद रखें कि हर स्ट्रीमिंग अनुरोध स्ट्रीम समाप्त होने तक अपना स्लॉट पकड़े रखता है, इसलिए एक लंबी स्ट्रीमिंग चैट और एक बड़े बैच को एक ही ट्रायल कुंजी पर मिक्स न करें।

जिन बातों की योजना बनाएँ

• कोई स्थानीय-केवल विकल्प नहीं। num_ctx और keep_alive होस्टेड साइड पर कोई अर्थ नहीं रखते। विंडो 100,000 टोकन की है, प्रॉम्प्ट और पूर्णता मिलकर।
• रेट लिमिट। एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोधों की अनुमति देती है; एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। उस सीमा से परे आपको 429 त्रुटि rate_limited या concurrency के साथ मिलती है। विराम के बाद पुनः प्रयास करें; अस्थायी ओवरलोड पर प्रतिक्रिया में Retry-After: 5 होता है।
• लागत। इनपुट की कीमत 1M टोकन प्रति $0.15 है और आउटपुट की 1M टोकन प्रति $0.50 है। एक स्क्रिप्ट जो 2,000 प्रॉम्प्ट भेजती है, जिनमें 600 इनपुट टोकन और 400 आउटपुट टोकन हैं, उस पर खर्च होता है: 2,000 x (600 x $0.15 + 400 x $0.50) / 1M = 2,000 x $0.00029 = $0.58।
• बिलिंग। प्रीपेड क्रेडिट, $20 से $500 तक, क्रिप्टो (TRC20 पर USDT या Base पर USDC) से भुगतान करें। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है।

एंडपॉइंट्स की तुलनात्मक समीक्षा के लिए, हमारे API मूल्य निर्धारण नोट या दस्तावेज़ पढ़ें।

अधिक गाइड

• Ollama API बनाम OpenAI API: एंडपॉइंट्स और कोड
• GUI (और होस्टेड फॉलबैक) के साथ Ollama का उपयोग कैसे करें