ഹോം / ഗൈഡുകൾ / LLM ഉപയോഗിച്ചുള്ള സൗജന്യ വിവർത്തന API

LLM ഉപയോഗിച്ചുള്ള സൗജന്യ വിവർത്തന API

വലിയ ഭാഷാ മോഡലുകൾ നിരവധി ഭാഷകൾക്കിടയിൽ നന്നായി വിവർത്തനം ചെയ്യുന്നു. നിരവധി providers അവ സൗജന്യമായി നൽകുന്നു. ചില സൗജന്യ മോഡലുകൾ വിവർത്തനത്തിനായി നിർമ്മിച്ചതാണ്, ഉദാഹരണത്തിന് Cohere Command A Translate. ഈ ഗൈഡ് വിവർത്തനത്തിനുള്ള സൗജന്യ മോഡലുകൾ, batch-ൽ വിവർത്തനം ചെയ്യുന്ന Python കോഡ്, ആസൂത്രണം ചെയ്യേണ്ട പരിധികൾ എന്നിവ കാണിക്കുന്നു. എല്ലാ അഭ്യർത്ഥനകളും FreeLLMAPI വഴി പോകുന്നു. അത് ഒരു OpenAI-compatible കീയ്ക്ക് പിന്നിൽ 45 സൗജന്യ provider ടിയറുകൾ ചേർക്കുന്നു.

കോഡ്, മോഡൽ പേരുകളും തത്സമയ കാറ്റലോഗ് ലേബലുകളും ഇംഗ്ലീഷിൽ കാണിക്കുന്നു.

വിവർത്തനത്തിനുള്ള സൗജന്യ മോഡലുകൾ

ചില സൗജന്യ മോഡലുകൾ നിരവധി ഭാഷകൾക്കോ ഒരു ഭാഷാ മേഖലയ്‌ക്കോ വേണ്ടി പരിശീലിപ്പിച്ചതാണ്. ഇന്നത്തെ സൗജന്യ catalog-ലെ ബഹുഭാഷാ, വിവർത്തന മോഡലുകൾ പട്ടിക കാണിക്കുന്നു.

സൗജന്യ വിവർത്തന, ബഹുഭാഷാ മോഡലുകൾ
മോഡൽസൗജന്യമായി ലഭ്യംകോൺടെക്സ്റ്റ്സൗജന്യ പരിധികൾ (ഏറ്റവും മികച്ച ഓഫർ)ടൂളുകൾദൃശ്യ ശേഷി
Typhoon 2.5 30B A3B InstructTyphoon131KOngoing free research API (shared rate limits)അതെഇല്ല
Qwen SEA-LION v4.5 27BSEA-LION33K10 അഭ്യർഥന/മിനിറ്റ്
10 RPM
ഇല്ലഇല്ല
Nemotron 3 Super 120BSEA-LION-10 അഭ്യർഥന/മിനിറ്റ്
10 RPM
അതെഇല്ല
Qwen SEA-LION v4 32BSEA-LION33K10 അഭ്യർഥന/മിനിറ്റ്
10 RPM
ഇല്ലഇല്ല
Llama SEA-LION v3 70BSEA-LION131K10 അഭ്യർഥന/മിനിറ്റ്
10 RPM
ഇല്ലഇല്ല
Gemma SEA-LION v4 27BCloudflare Workers AI, SEA-LION131K10 അഭ്യർഥന/മിനിറ്റ്
10 RPM
ഇല്ലഇല്ല
Command A TranslateCohere256K20 അഭ്യർഥന/മിനിറ്റ്
33 അഭ്യർഥന/ദിവസം
~1-2M
അതെഇല്ല
Tiny Aya GlobalCohere8K20 അഭ്യർഥന/മിനിറ്റ്
33 അഭ്യർഥന/ദിവസം
1K calls/mo shared
ഇല്ലഇല്ല
North Small TranslateCohere33K20 അഭ്യർഥന/മിനിറ്റ്
33 അഭ്യർഥന/ദിവസം
~1-2M
ഇല്ലഇല്ല
Tiny Aya EarthCohere8K20 അഭ്യർഥന/മിനിറ്റ്
33 അഭ്യർഥന/ദിവസം
1K calls/mo shared
ഇല്ലഇല്ല
Tiny Aya FireCohere8K20 അഭ്യർഥന/മിനിറ്റ്
33 അഭ്യർഥന/ദിവസം
1K calls/mo shared
ഇല്ലഇല്ല
Tiny Aya WaterCohere8K20 അഭ്യർഥന/മിനിറ്റ്
33 അഭ്യർഥന/ദിവസം
1K calls/mo shared
ഇല്ലഇല്ല

പൊരുത്തപ്പെടുന്ന 16 സൗജന്യ മോഡലുകളിൽ 12 എണ്ണം കാണിക്കുന്നു. എല്ലാ മോഡലുകളും കാണുക.

FreeLLMAPI കാറ്റലോഗിൽ നിന്നുള്ള തത്സമയ ഡാറ്റ (പതിപ്പ് 2026.11.19, 2026-11-19 ൽ പരിശോധിച്ചത്). സൗജന്യ പരിധികൾ പലപ്പോഴും മാറുന്നു. കാറ്റലോഗ് എല്ലാ ദിവസവും പരിശോധിക്കുന്നു.

മോഡൽ കുടുംബംഉദ്ദേശ്യംഉറവിടം
Command A Translate (Cohere)23 ഭാഷകളിൽ വിവർത്തനം, അറബിക്, ചൈനീസ്, ഹിന്ദി, ജാപ്പനീസ്, പേർഷ്യൻ, ഉക്രേനിയൻ എന്നിവ ഉൾപ്പെടെCohere changelog, 28 August 2025
Aya Expanse (Cohere)23 ഭാഷകളിൽ ബഹുഭാഷാ chatCohere docs
SEA-LION (AI Singapore)തെക്കുകിഴക്കൻ ഏഷ്യൻ ഭാഷകൾ, 11 അല്ലെങ്കിൽ കൂടുതൽsea-lion.ai
Typhoonതായ്opentyphoon.ai

പൊതു മോഡലുകളും നന്നായി വിവർത്തനം ചെയ്യുന്നു, പ്രധാനമായും വലിയ ഭാഷകൾക്കിടയിൽ. ഇന്നത്തെ ഏറ്റവും ശക്തമായ സൗജന്യ പൊതു മോഡലുകൾ ഇവയാണ്:

128K+ context ഉള്ള ശക്തമായ സൗജന്യ പൊതു മോഡലുകൾ
മോഡൽസൗജന്യമായി ലഭ്യംകോൺടെക്സ്റ്റ്സൗജന്യ പരിധികൾ (ഏറ്റവും മികച്ച ഓഫർ)ടൂളുകൾദൃശ്യ ശേഷി
GLM 5.3APINex, UnoRouter1M5 അഭ്യർഥന/മിനിറ്റ്
10M weighted tokens/day shared across APINex free routes; 4x token multiplier; 5 requests/minute/account
അതെഇല്ല
GLM 5.3 FlashAPINex, BlazeAPI, NVIDIA NIM +1 കൂടി1M40 അഭ്യർഥന/മിനിറ്റ്
40 RPM
അതെഅതെ
Gemini 3.8 FlashAPINex, Google AI Studio1M5 അഭ്യർഥന/മിനിറ്റ്
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
അതെഅതെ
Qwen3.8 Flash NextAMD Radeon Cloud, BlazeAPI, ElectronHub262KRecurring daily account allowanceഅതെഇല്ല
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditഅതെഅതെ
Deepseek V4.1 FlashAPINex1M5 അഭ്യർഥന/മിനിറ്റ്
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
ഇല്ലഇല്ല
Gemini 3.7 FlashGoogle AI Studio1M10 അഭ്യർഥന/മിനിറ്റ്
20 അഭ്യർഥന/ദിവസം
250,000 ടോക്കൺ/മിനിറ്റ്
~3M
അതെഅതെ
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditഅതെഅതെ

പൊരുത്തപ്പെടുന്ന 184 സൗജന്യ മോഡലുകളിൽ 8 എണ്ണം കാണിക്കുന്നു. എല്ലാ മോഡലുകളും കാണുക.

FreeLLMAPI കാറ്റലോഗിൽ നിന്നുള്ള തത്സമയ ഡാറ്റ (പതിപ്പ് 2026.11.19, 2026-11-19 ൽ പരിശോധിച്ചത്). സൗജന്യ പരിധികൾ പലപ്പോഴും മാറുന്നു. കാറ്റലോഗ് എല്ലാ ദിവസവും പരിശോധിക്കുന്നു.

ഓരോ മോഡലും നിങ്ങളുടെ സ്വന്തം വാചകങ്ങളും ഭാഷാ ജോഡികളും ഉപയോഗിച്ച് പരീക്ഷിക്കുക. ജോഡികൾക്കനുസരിച്ച് ഗുണനിലവാരം വളരെയധികം മാറുന്നു. ഇംഗ്ലീഷ് മുതൽ സ്പാനിഷ് വരെ നല്ലതായ ഒരു മോഡൽ തായ് മുതൽ വിയറ്റ്നാമീസ് വരെ ദുർബലമായേക്കാം.

gateway സജ്ജമാക്കുക

FreeLLMAPI ഇൻസ്റ്റാൾ ചെയ്യുക, ഡാഷ്‌ബോർഡിലെ Keys പേജിൽ നിങ്ങളുടെ സൗജന്യ provider കീകൾ ചേർക്കുക, ഏകീകൃത കീ പകർത്തുക. മുകളിലെ വിവർത്തന മോഡലുകൾക്കായി, ഒരു Cohere കീ, ഒരു SEA-LION കീ അല്ലെങ്കിൽ ഒരു NVIDIA കീ ചേർക്കുക. പൊതു മോഡലുകൾക്ക് Google, Groq അല്ലെങ്കിൽ Mistral കീകൾ ചേർക്കുക.

ഒരു വിവർത്തനം ഇൻസ്റ്റാൾ ചെയ്ത് പരീക്ഷിക്കുക

curl -fsSL https://freellmapi.co/install.sh | bash

curl http://localhost:3001/v1/chat/completions \
  -H "Authorization: Bearer <unified-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "command-a-translate-08-2025",
    "temperature": 0,
    "messages": [
      {"role": "system", "content": "Translate the user text into German. Return only the translation."},
      {"role": "user", "content": "Your order has shipped."}
    ]
  }'

നിശ്ചിത മോഡൽ ID ഓരോ തവണയും ഒരേ വിവർത്തന രീതി നൽകുന്നു. ആ മോഡൽ അതിന്റെ സൗജന്യ പരിധിയിലെത്തിയാൽ, അതേ മോഡൽ മറ്റൊരു provider-ൽ സൗജന്യമല്ലെങ്കിൽ അഭ്യർത്ഥന പരാജയപ്പെടുന്നു. മറ്റ് മോഡലുകളിൽ തുടരാൻ, translate പോലെ ഒരു fallback chain profile ഉണ്ടാക്കുക. നിങ്ങൾ തിരഞ്ഞെടുത്ത മോഡലുകൾ ക്രമത്തിൽ അതിൽ ചേർക്കുക. പിന്നെ മോഡലായി auto:translate ഉപയോഗിക്കുക.

Python ഉപയോഗിച്ച് batch-ൽ വിവർത്തനം ചെയ്യുക

ഓരോ സ്ട്രിംഗിനും ഒരു അഭ്യർത്ഥന എന്നത് നിങ്ങളുടെ അഭ്യർത്ഥന പരിധി വേഗത്തിൽ ഉപയോഗിക്കുന്നു. 20 മുതൽ 50 വരെ ചെറിയ സ്ട്രിംഗുകൾ ഒരു JSON list ആയി ഒരു അഭ്യർത്ഥനയിൽ അയയ്ക്കുക. ഉത്തരത്തിൽ അതേ എണ്ണം ഇനങ്ങളും അതേ placeholders ഉം ഉണ്ടോ എന്ന് കോഡ് പരിശോധിക്കുന്നു. പരിശോധന പരാജയപ്പെട്ടാൽ, അത് സ്ട്രിംഗുകൾ ഒന്നൊന്നായി വിവർത്തനം ചെയ്യുന്നു.

translate.py

import json
import os
import re
import time

import openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:3001/v1",
    api_key=os.environ["FREELLMAPI_API_KEY"],
    max_retries=3,
    timeout=90,
)
MODEL = "auto:translate"  # a profile with your translation models
PLACEHOLDER = re.compile(r"\{[^}]+\}|%\w|<[^>]+>")  # {name}, %s, <b>

SYSTEM = (
    "You are a professional translator. Translate each string into {lang}. "
    "Keep placeholders such as {{name}}, %s and HTML tags exactly as they are. "
    "Use this glossary: {glossary}. "
    "Return only a JSON array of strings, in the same order and with the same length."
)

def chat(messages):
    for attempt in range(6):
        try:
            resp = client.chat.completions.create(model=MODEL, messages=messages, temperature=0)
            return resp.choices[0].message.content or ""
        except openai.RateLimitError as err:
            header = err.response.headers.get("retry-after", "")
            time.sleep(min(int(header) if header.isdigit() else 2 ** attempt, 120))
    raise RuntimeError("Rate limited on every provider")

def same_placeholders(src: str, dst: str) -> bool:
    return sorted(PLACEHOLDER.findall(src)) == sorted(PLACEHOLDER.findall(dst))

def parse_list(text: str):
    text = text.strip().removeprefix("```json").removeprefix("```").removesuffix("```")
    return json.loads(text)

def translate_batch(strings, lang, glossary="none"):
    system = SYSTEM.format(lang=lang, glossary=glossary)
    try:
        out = parse_list(chat([
            {"role": "system", "content": system},
            {"role": "user", "content": json.dumps(strings, ensure_ascii=False)},
        ]))
        if len(out) == len(strings) and all(same_placeholders(s, d) for s, d in zip(strings, out)):
            return out
    except (json.JSONDecodeError, TypeError):
        pass
    # Fallback: one string per request
    return [translate_one(s, system) for s in strings]

def translate_one(s, system):
    text = chat([
        {"role": "system", "content": system},
        {"role": "user", "content": json.dumps([s], ensure_ascii=False)},
    ])
    try:
        return str(parse_list(text)[0])
    except (json.JSONDecodeError, TypeError, IndexError, KeyError):
        return text.strip()  # keep the raw answer; review it later

def translate_all(strings, lang, size=30, glossary="none"):
    result = []
    for i in range(0, len(strings), size):
        result.extend(translate_batch(strings[i:i + size], lang, glossary))
    return result

if __name__ == "__main__":
    ui = ["Welcome back, {name}!", "You have %s new messages.", "<b>Save</b> your changes"]
    print(translate_all(ui, "French", glossary="messages = messages; Save = Enregistrer"))

വിവർത്തനത്തിന് temperature=0 ഉപയോഗിക്കുക. അപ്പോൾ ഓരോ റണ്ണിലും ഔട്ട്പുട്ട് കൂടുതൽ സ്ഥിരതയുള്ളതാകും. വിവർത്തനങ്ങൾ ഒരു ഫയലിലോ ഡേറ്റാബേസിലോ സംരക്ഷിക്കുക, പുതിയതോ മാറ്റം വന്നതോ ആയ സ്ട്രിംഗുകൾ മാത്രം വിവർത്തനം ചെയ്യുക.

ഗ്ലോസറികൾ, ശൈലി, നീണ്ട രേഖകൾ

  • ഗ്ലോസറി: system message-ൽ ഉൽപ്പന്ന പേരുകളും നിശ്ചിത പദങ്ങളും പട്ടികപ്പെടുത്തുക. വിവർത്തനം ചെയ്യാൻ പാടില്ലാത്ത പദങ്ങൾ മോഡലിനോട് പറയുക.
  • ശൈലി: രജിസ്റ്റർ പറയുക, ഉദാഹരണത്തിന് ജർമ്മനിൽ ഔപചാരികമായ "Sie" അല്ലെങ്കിൽ ഫ്രഞ്ചിൽ അനൗപചാരികമായ "tu".
  • സന്ദർഭം: വാചകം എവിടെ കാണിക്കുന്നു എന്നതിനെക്കുറിച്ച് ഒരു വരി ചേർക്കുക, ഉദാഹരണത്തിന് "ഒരു ബാങ്കിംഗ് ആപ്പിലെ ബട്ടൺ ലേബലുകൾ". അത് ഇല്ലാതെ ചെറിയ സ്ട്രിംഗുകൾ പലപ്പോഴും അവ്യക്തമാണ്.
  • നീണ്ട രേഖകൾ: ഖണ്ഡിക അതിരുകളിൽ വിഭജിക്കുക. ഓരോ ഭാഗവും മുമ്പത്തെ ഖണ്ഡികയെ സന്ദർഭമായി ചേർത്ത് അയയ്ക്കുക, പുതിയ ഭാഗം മാത്രം വിവർത്തനം ചെയ്യുക.
  • ഒരു രേഖയ്ക്ക് ഒരേ മോഡൽ: രേഖയുടെ ID സഹിതം X-Session-Id ഹെഡർ അയയ്ക്കുക. FreeLLMAPI ഒരു session-നെ 30 മിനിറ്റ് ഒരേ മോഡലിൽ നിലനിർത്തുന്നു, അതിനാൽ പദങ്ങൾ ഒരേപോലെ തുടരുന്നു.

FreeLLMAPI-ക്ക് ഒരേ അഭ്യർത്ഥനകൾക്കായി ഒരു opt-in response cache ഉണ്ട്. cache hit provider ക്വോട്ട ഉപയോഗിക്കുന്നില്ല. X-FreeLLM-Cache ഹെഡർ ഉപയോഗിച്ച് ഒരു അഭ്യർത്ഥനയ്ക്കായി ഇത് ഓണാക്കാനോ ഓഫാക്കാനോ കഴിയും. temperature=0 ഉപയോഗിച്ചാൽ, ഒരേ സ്ട്രിംഗും ഒരേ നിർദ്ദേശങ്ങളും ഒരേ അഭ്യർത്ഥന നൽകുന്നു, അതിനാൽ ആവർത്തിച്ചുള്ള സ്ട്രിംഗുകൾ cache-ൽ നിന്ന് വരുന്നു.

ഗുണനിലവാരം സ്വയമേവ പരിശോധിക്കുക

ലളിതമായ പരിശോധനകൾ ഒരാൾ വായിക്കുന്നതിന് മുമ്പ് മോശം വിവർത്തനങ്ങളിൽ ഭൂരിഭാഗവും കണ്ടെത്തുന്നു. ഓരോ batch-ന് ശേഷവും അവ പ്രവർത്തിപ്പിക്കുക, പരാജയപ്പെട്ട സ്ട്രിംഗുകൾ മാത്രം ഒരു അവലോകന പട്ടികയിലേക്ക് അയയ്ക്കുക.

  • Placeholders: വിവർത്തനത്തിൽ ഉറവിടത്തിലെ അതേ placeholders ഉം tags ഉം ഉണ്ടായിരിക്കണം. മുകളിലെ കോഡ് ഇത് ഇതിനകം പരിശോധിക്കുന്നു.
  • നീളം: ഉറവിടത്തിന്റെ മൂന്നിലൊന്നിൽ കുറവോ മൂന്നിരട്ടിയിൽ കൂടുതലോ ആയ വിവർത്തനം പലപ്പോഴും തെറ്റാണ്.
  • വിവർത്തനം ചെയ്യാത്ത വാചകം: ഔട്ട്പുട്ട് ഇൻപുട്ടിന് തുല്യമാണെങ്കിൽ, മോഡൽ അത് വിവർത്തനം ചെയ്തിട്ടില്ല.
  • തിരികെ വിവർത്തനം: പ്രധാനപ്പെട്ട വാചകത്തിന്, ഫലം വ്യത്യസ്ത മോഡൽ ഉപയോഗിച്ച് ഉറവിട ഭാഷയിലേക്ക് തിരികെ വിവർത്തനം ചെയ്യുക. വാക്കുകളല്ല, അർത്ഥമാണ് താരതമ്യം ചെയ്യുക.

അവലോകനത്തിനുള്ള സ്ട്രിംഗുകൾ കണ്ടെത്തുക

def needs_review(src: str, dst: str) -> bool:
    ratio = len(dst) / max(len(src), 1)
    return (
        not same_placeholders(src, dst)
        or dst.strip() == src.strip()
        or ratio < 0.33
        or ratio > 3.0
    )

review = [(s, d) for s, d in zip(ui, translated) if needs_review(s, d)]

തിരികെ വിവർത്തനത്തിന്, നിങ്ങളുടെ വിവർത്തന profile-ൽ ഇല്ലാത്ത ഒരു നിശ്ചിത മോഡൽ ID പിൻ ചെയ്യുക. വ്യത്യസ്ത മോഡൽ ആദ്യ മോഡലിന്റെ പിശകുകൾ ആവർത്തിക്കാൻ സാധ്യത കുറവാണ്.

പരിധികളും സത്യസന്ധമായ വിട്ടുവീഴ്ചകളും

ആപ്പ് സ്ട്രിംഗുകൾ, പിന്തുണാ മറുപടികൾ, ആന്തരിക രേഖകൾ, പരീക്ഷണങ്ങൾ എന്നിവയ്ക്ക് സൗജന്യ ടിയറുകൾ നല്ലതാണ്. ഈ പരിധികൾ ആസൂത്രണം ചെയ്യുക:

പരിധിവിവർത്തനത്തിലുള്ള പ്രഭാവംചെയ്യേണ്ടത്
മിനിറ്റിലും ദിവസത്തിലും അഭ്യർത്ഥനകൾഒരു വലിയ ഫയൽ ഒരു ദിവസത്തെ മുഴുവൻ ക്വോട്ടയും ഉപയോഗിച്ചേക്കാംഒരു അഭ്യർത്ഥനയിൽ 20 മുതൽ 50 വരെ സ്ട്രിംഗുകൾ batch ചെയ്യുക. കൂടുതൽ providers-ൽ നിന്ന് കീകൾ ചേർക്കുക.
വിദഗ്ധ മോഡലുകളിൽ കുറഞ്ഞ ദിവസ പരിധികൾചില വിവർത്തന മോഡലുകൾ ദിവസത്തിൽ കുറച്ച് അഭ്യർത്ഥനകൾ മാത്രമേ അനുവദിക്കൂഅവ profile-ൽ ആദ്യം വെക്കുക, പൊതു മോഡലുകൾ അവയ്ക്ക് ശേഷം വെക്കുക
failover-ന് ശേഷമുള്ള വ്യത്യസ്ത മോഡലുകൾശൈലിയും പദങ്ങളും batch-കൾക്കിടയിൽ മാറിയേക്കാംഒരു ഗ്ലോസറിയും X-Session-Id ഹെഡറും ഉപയോഗിക്കുക
SLA ഇല്ലദിവസത്തിനിടയിൽ latency മാറുന്നുനിശ്ചിത സമയത്ത് ഉത്തരം നൽകേണ്ട തത്സമയ വിവർത്തനത്തിന് സൗജന്യ ടിയറുകൾ ഉപയോഗിക്കരുത്
ഡാറ്റ നിബന്ധനകൾചില സൗജന്യ ടിയറുകൾ മോഡലുകൾ പരിശീലിപ്പിക്കാൻ prompts ഉപയോഗിച്ചേക്കാംആ providers-ലേക്ക് രഹസ്യ വാചകം അയയ്ക്കരുത്

യന്ത്ര വിവർത്തനം തെറ്റായേക്കാം. പ്രസിദ്ധീകരിക്കുന്നതിന് മുമ്പ് നിയമപരമായ, വൈദ്യശാസ്ത്രപരമായ, വിപണന വാചകം ഒരു മാതൃഭാഷാ സംസാരിക്കുന്നയാൾ അവലോകനം ചെയ്യട്ടെ. ശൃംഖലയിലെ എല്ലാ കീകളും പരിധിയിലെത്തുമ്പോൾ, gateway Retry-After ഹെഡറോടെ 429 നൽകുന്നു. മുകളിലെ കോഡ് കാത്തിരുന്ന് വീണ്ടും ശ്രമിക്കുന്നു.

ഇവയെല്ലാം ഒരൊറ്റ കീ വഴി ഉപയോഗിക്കുക. FreeLLMAPI ഒരു ഓപ്പൺ-സോഴ്സ്, സ്വയം ഹോസ്റ്റ് ചെയ്യാവുന്ന റൂട്ടറാണ്. ഇത് ഈ സൗജന്യ ടയറുകളെല്ലാം ഒരൊറ്റ OpenAI-അനുയോജ്യ എൻഡ്‌പോയിന്റിനു പിന്നിൽ വയ്ക്കുന്നു. ഒരു മോഡലിന്റെ നിരക്ക് പരിധി എത്തുമ്പോൾ മറ്റൊന്നിലേക്ക് മാറുന്നു. കാറ്റലോഗ് ബ്രൗസ് ചെയ്യുക അല്ലെങ്കിൽ തത്സമയമാക്കുക.

പതിവ് ചോദ്യങ്ങൾ

LLM അടിസ്ഥാനമാക്കിയുള്ള സൗജന്യ വിവർത്തന API ഉണ്ടോ?

ഉണ്ട്. Cohere Command A Translate പോലുള്ള വിവർത്തന മോഡലുകൾ ഉൾപ്പെടെ നിരവധി providers ബഹുഭാഷാ LLM-കൾ സൗജന്യമായി നൽകുന്നു. FreeLLMAPI അവ ഒരു OpenAI-compatible കീ വഴി നൽകുന്നു.

വിവർത്തനത്തിന് ഏറ്റവും നല്ല സൗജന്യ LLM ഏതാണ്?

അത് ഭാഷാ ജോഡിയെ ആശ്രയിച്ചിരിക്കുന്നു. Command A Translate 23 ഭാഷകൾ ഉൾക്കൊള്ളുന്നു, SEA-LION തെക്കുകിഴക്കൻ ഏഷ്യൻ ഭാഷകൾക്കും Typhoon തായ്ക്കും വേണ്ടി നിർമ്മിച്ചതാണ്. നിങ്ങളുടെ സ്വന്തം വാചകങ്ങൾ ഉപയോഗിച്ച് പരീക്ഷിക്കുക.

റേറ്റ് പരിധികളിൽ എത്താതെ എങ്ങനെ നിരവധി സ്ട്രിംഗുകൾ വിവർത്തനം ചെയ്യാം?

20 മുതൽ 50 വരെ സ്ട്രിംഗുകൾ ഒരു JSON list ആയി ഒരു അഭ്യർത്ഥനയിൽ അയയ്ക്കുക, temperature 0 ഉപയോഗിക്കുക, ഫലങ്ങൾ cache ചെയ്യുക, കൂടുതൽ providers-ൽ നിന്ന് കീകൾ ചേർക്കുക.

LLM വിവർത്തനങ്ങളിൽ placeholders ഉം HTML tags ഉം എങ്ങനെ സംരക്ഷിക്കാം?

അവ കൃത്യമായി സൂക്ഷിക്കാൻ മോഡലിനോട് പറയുക, പിന്നെ ഓരോ വിവർത്തനവും പരിശോധിക്കുക. placeholders പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, ആ സ്ട്രിംഗ് വീണ്ടും, ഒറ്റയ്ക്ക് വിവർത്തനം ചെയ്യുക.

ഉൽപ്പാദനത്തിന് സൗജന്യ LLM വിവർത്തനം മതിയാകുമോ?

ആപ്പ് സ്ട്രിംഗുകൾക്കും ആന്തരിക വാചകത്തിനും, ഗ്ലോസറിയും പരിശോധനകളും ഉണ്ടെങ്കിൽ പലപ്പോഴും അതെ. നിയമപരമായ, വൈദ്യശാസ്ത്രപരമായ, വിപണന വാചകം ഒരു മാതൃഭാഷാ സംസാരിക്കുന്നയാൾ അവലോകനം ചെയ്യട്ടെ.

അനുബന്ധ ഗൈഡുകൾ

ഉറവിടങ്ങൾ

എല്ലാ ഗൈഡുകളും · എല്ലാ സൗജന്യ മോഡലുകളും കാണുക