JetBrains Mellum2.1లో 12 బిలియన్ పారామీటర్ల మోడల్ ఉండగా, 2.5 బిలియన్ పారామీటర్లు క్రియాశీలంగా ఉంటాయి. BF16 రిపాజిటరీతో పాటు ప్రత్యేక GGUF రిపాజిటరీ కూడా Hugging Faceలో అందుబాటులో ఉన్నాయి. మొదటి స్థానిక రన్ కోసం, GGUF రిపాజిటరీ llama.cpp మార్గాన్ని వివరిస్తుంది: అవసరమైనప్పుడు quantized ఫైల్‌ను డౌన్‌లోడ్ చేయండి, స్థానిక సర్వర్‌ను ప్రారంభించండి, prompt పంపండి, ఏ కోడింగ్ agentకైనా రిపాజిటరీ ప్రాప్యత ఇచ్చే ముందు సమాధానాన్ని పరిశీలించండి.

ఇది డాక్యుమెంటేషన్ ఆధారంగా రూపొందించిన సెటప్ మార్గదర్శిని. BIG CHANGE Mellum2.1ను ఇన్‌స్టాల్ చేయలేదు, దిగువ ఆదేశాలను అమలు చేయలేదు. సర్వర్ నుంచి స్థానిక completion రావడమే విజయ తనిఖీ; దాంతో కోడ్ నాణ్యత, agent విశ్వసనీయత లేదా మీ హార్డ్‌వేర్‌పై పనితీరు నిర్ధారణ కాదు.

మీకు కావాల్సినవి

  • ఎంచుకున్న మోడల్, దాని రన్‌టైమ్‌కు సరిపడా మెమరీ, నిల్వ ఉన్న Windows, macOS లేదా Linux కంప్యూటర్. అసలు మోడల్ BF16లో ఉందని, దాని context పొడవు 131,072 tokens అని JetBrains కార్డ్ చెబుతుంది. సిఫారసు చేసిన Q4_K_M ఫైల్ 8.1 GB అని GGUF రిపాజిటరీ పేర్కొంటుంది. అది ఫైల్ పరిమాణం మాత్రమే; రన్‌టైమ్ మెమరీ మొత్తానికి అంచనా కాదు: రన్‌టైమ్, context, ఇతర ప్రక్రియలకు అదనపు వనరులు అవసరం. కనీస మెమరీ అవసరాన్ని JetBrains ప్రచురించలేదు.
  • ప్రారంభ సాఫ్ట్‌వేర్, మోడల్ డౌన్‌లోడ్‌కు ఇంటర్నెట్ కనెక్షన్ అవసరం. inference అభ్యర్థన మాత్రం స్థానిక సర్వర్‌కు వెళ్లవచ్చు.
  • llama.cpp మరియు ఒక టెర్మినల్. రిపాజిటరీలో ఈ ఆదేశం ఉంది winget install llama.cpp Windows కోసం, అలాగే ఒక llama serve స్థానికంగా సర్వ్ చేయడానికి ఉపయోగించే ఆదేశం.

ఈ మోడల్ Apache 2.0 లైసెన్స్‌తో విడుదలైంది. weightsకు వినియోగ రుసుము పేర్కొనలేదు; హార్డ్‌వేర్, విద్యుత్, నిల్వ, అద్దెకు తీసుకునే మౌలిక సదుపాయాల ఖర్చులను JetBrains లెక్కించలేదు. BF16 రిపాజిటరీకి ప్రస్తుతం inference provider సేవలందించడం లేదని ఆ మోడల్ కార్డ్ చెబుతుంది. GGUF రిపాజిటరీ వేరే quantized artifact; దానికి స్వంత llama.cpp త్వరిత ప్రారంభ మార్గదర్శిని ఉంది.

దశ 1: llama.cppను ఇన్‌స్టాల్ చేసి స్థానిక సర్వర్‌ను ప్రారంభించండి

Windowsలో PowerShell ఉపయోగించి llama.cppను ఇన్‌స్టాల్ చేయడానికి అధికారిక Mellum2.1 GGUF త్వరిత ప్రారంభ మార్గదర్శిని:

PowerShell
winget install llama.cpp

ఈ llama ఆదేశం ఇంకా PATHలో చేరకపోతే కొత్త టెర్మినల్ తెరవండి. సిఫారసు చేసిన Q4_K_M buildను ప్రారంభించి, స్థానిక కంప్యూటర్‌కే bind అయ్యేలా port 8080ను స్పష్టంగా ఎంచుకోండి:

PowerShell
llama serve -hf JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:Q4_K_M --host 127.0.0.1 --port 8080

ఈ మోడల్ ID, quantizationను llama serve కోసం GGUF రిపాజిటరీ వివరిస్తుంది; Windows ఇన్‌స్టాలేషన్ మార్గాన్నీ అందిస్తుంది. llama.cpp సర్వర్ సూచన పత్రం లో --host మరియు --port గురించి వివరిస్తుంది; రిపాజిటరీ ఉదాహరణ endpoint http://localhost:8080/v1 గా ఉంది. macOS, Linuxలో అదే GGUF రిపాజిటరీ llama.cppను curl -LsSf https://llama.app/install.sh | sh తో ఇన్‌స్టాల్ చేసి, ఆపై ఇదే serve ఆదేశాన్ని ఉపయోగించాలని సూచిస్తుంది.

మొదటి ప్రతిస్పందనకు ముందు ప్రక్రియ మోడల్‌ను డౌన్‌లోడ్ చేయాలి. Q4_K_M ఫైల్ పరిమాణం 8.1 GBగా ఇవ్వబడింది. ఈ పరీక్షలో సర్వర్ మీ కంప్యూటర్‌కే bind అయ్యేలా ఉంచండి; దాన్ని నెట్‌వర్క్‌కు బహిర్గతం చేయకండి, promptలో credentials పెట్టకండి. చిన్నదైన 7.0 GB MXFP4_MOE ఫైల్‌తో పాటు పెద్ద Q6_K, Q8_0, BF16 రూపాలనూ రిపాజిటరీ జాబితా చేస్తుంది. quantization మోడల్ artifactను మారుస్తుంది; ఫైల్ పరిమాణం ఒక్కటే చూస్తే ఒక కంప్యూటర్ ఉపయోగకరమైన context పొడవు లేదా వేగంతో దాన్ని అందించగలదో తెలియదు.

ఆదేశం ప్రారంభం కాకపోతే, ముందుగా ఖచ్చితమైన మోడల్ ID, అందుబాటులో ఉన్న disk స్థలం, llama.cpp వెర్షన్, పూర్తి error text తనిఖీ చేయండి. మెమరీ కేటాయింపు విఫలమైతే ఆగి, ప్రస్తుత llama.cpp డాక్యుమెంటేషన్ ప్రకారం రన్‌టైమ్ ఎంపికలు, context సెట్టింగ్‌లను పరిశీలించండి; అది మోడల్‌లో లోపం ఉందని నిరూపించదు. ప్రచురించిన 131,072-token context మీ కంప్యూటర్‌లో సరిపోతుందని ఊహించకండి.

దశ 2: smoke-test prompt పంపండి

సర్వర్‌ను నడుస్తూనే ఉంచండి. రెండో PowerShell విండోలో దాని స్థానిక APIకి చిన్న అభ్యర్థన పంపండి:

PowerShell
$body = @{
  model = "JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF"
  messages = @(
    @{ role = "user"; content = "Reply with exactly: MELLUM21-LOCAL-OK" }
  )
  # Author-selected budget for this short smoke test; not a JetBrains recommendation.
  max_tokens = 512
  temperature = 0.6
  top_p = 0.95
  top_k = 20
} | ConvertTo-Json -Depth 5

$response = Invoke-RestMethod -Uri "http://localhost:8080/v1/chat/completions" -Method Post -ContentType "application/json" -Body $body

$choice = $response.choices[0]
[pscustomobject]@{
  finish_reason = $choice.finish_reason
  has_reasoning_content = -not [string]::IsNullOrWhiteSpace($choice.message.reasoning_content)
  content = $choice.message.content
}

మోడల్ ID, స్థానిక endpoint, sampling విలువలు రిపాజిటరీ API ఉదాహరణను అనుసరిస్తాయి. max_tokens = 512 ఈ చిన్న పరీక్ష కోసం ఎంచుకున్న పరిమిత విలువ; మోడల్ కార్డ్ సిఫారసు కాదు. Mellum2.1 ఒక thinking model; GGUF కార్డ్ ప్రకారం ఇది reasoningను <think>...</think> blocksలో ఇస్తుంది. ప్రత్యేకమైన reasoning_content fieldలో ఏదైనా ఉందో లేదో కోడ్ చూపుతుంది, కానీ ఆ fieldను ముద్రించదు. రన్‌టైమ్ reasoning formatపై ఆధారపడి, content లో ఇంకా <think> text ఉండవచ్చు. ఈ prompt smoke test మాత్రమే; మోడల్ నాణ్యత benchmark కాదు.

అభ్యర్థన connection లేదా server errorకు బదులుగా completion ఇచ్చి, finish_reason అనేది length కాకుండా ఉండి, చివరి content లో MELLUM21-LOCAL-OK ఉన్నప్పుడే ప్రాథమిక తనిఖీ విజయవంతం. HTTP విజయమే సరిపోదు: thinking model అడిగిన చివరి text ఇవ్వకముందే చిన్న output budgetను ఖర్చు చేయవచ్చు. output ఖాళీగా ఉన్నా, marker లేకపోయినా, లేదా finish_reason విలువ length అయితే, మోడల్ విఫలమైందని తేల్చకుండా దీనిని అసంపూర్ణ పరీక్షగా పరిగణించండి; పరిమిత output budget పెంచి మళ్లీ ప్రయత్నించండి. PowerShell connection failure చూపితే, మొదటి టెర్మినల్‌లో సర్వర్ నడుస్తోందో, అభ్యర్థన port 8080ను వాడుతోందో నిర్ధారించండి. సర్వర్ error ఇస్తే ఖచ్చితమైన సందేశాన్ని భద్రపరచి, coding agentను పరీక్షించే ముందు సమస్యను పరిష్కరించండి. విజయవంతమైన ప్రతిస్పందన ఈ స్థానిక inference మార్గం ఒక అభ్యర్థనకు సమాధానం ఇవ్వగలదని మాత్రమే నిర్ధారిస్తుంది; మోడల్ సురక్షితంగా కోడ్‌ను మార్చగలదని కాదు.

దశ 3: agentను కలపడానికి ముందు తనిఖీ చేయండి

మొదటి మూల్యాంకనాన్ని ప్రత్యక్ష ప్రాజెక్ట్‌కు వేరుగా ఉంచండి. తెలిసిన చిన్న పనితో తాత్కాలిక రిపాజిటరీ వాడి, మోడల్ artifact, quantization, llama.cpp వెర్షన్, ఆపరేటింగ్ సిస్టమ్, context సెట్టింగ్, prompt, output, పట్టిన సమయం, వనరుల వినియోగాన్ని నమోదు చేయండి. పరిమిత మార్పు కోరండి, ప్రతిపాదిత diffను పరిశీలించండి, రిపాజిటరీలోని ప్రస్తుత పరీక్షలను మీరే అమలు చేయండి. పోలిక కావాలంటే మీ ప్రస్తుత baselineతో అదే పనిని మళ్లీ చేయండి. ఒక prompt లేదా ఒక్క విజయవంతమైన test run benchmark కాదు.

మోడల్ సర్వర్ textను ఇస్తుంది; రన్‌టైమ్, అభ్యర్థన formatను బట్టి నిర్మిత tool-call పనులకు మద్దతు ఉండవచ్చు. ఏ toolsను agent వాడవచ్చో అది స్వయంగా నిర్ణయించదు, వాటిని సురక్షితంగా అమలు చేయదు. చుట్టూ ఉన్న agentే రిపాజిటరీ ప్రాప్యత, shell ఆదేశాలు, ఫైల్ మార్పులు, పరీక్షల అమలును నియంత్రిస్తుంది. మొదట read-only లేదా గట్టిగా పరిమిత ప్రాప్యత ఇవ్వండి; రాయడం, ఆదేశాల కోసం అనుమతి తప్పనిసరి చేయండి; ప్రతి diffను సమీక్షించండి; పరీక్ష రిపాజిటరీ, promptలలో రహస్యాలను ఉంచకండి. agent పనిని మించి ప్రయత్నించినా, సంబంధం లేని ఫైళ్లను మార్చినా, విఫలమైన పరీక్షను వివరించలేకపోయినా ఆపండి.

ప్రైవేట్ ఉపయోగం కోసం inference ఎక్కడ నడుస్తోంది, agent ఎలా configure అయిందో నిర్ధారించండి. అభ్యర్థనలు స్థానిక endpointకే ఉంటే స్థానిక మోడల్ ప్రక్రియ promptలను మీ కంప్యూటర్‌లోనే ఉంచగలదు; అయితే ఇతర ఫీచర్ల కోసం agent బాహ్య సేవలను పిలవవచ్చు. ప్రైవేట్ కోడ్ లేదా డేటా వాడే ముందు ఆ అప్లికేషన్‌లో network access, logs, telemetry, tool permissions తనిఖీ చేయండి.

దశ 4: ప్రచురిత ఆధారాలు ఏమి చూపుతాయి, ఏమి చూపవు

Mellum2.1ను 12B mixture-of-experts మోడల్‌గా, 2.5B క్రియాశీల పారామీటర్లు, BF16 precision, 131,072-token contextతో JetBrains వివరిస్తుంది. విడుదల Apache 2.0 కింద ఉందని, sandboxed software environmentsలో reinforcement learning సహా post-training జరిగిందని మోడల్ కార్డ్ చెబుతుంది. agentic coding మూల్యాంకనాలతో సహా benchmark ఫలితాలను కూడా JetBrains ప్రచురించింది. అవి JetBrains స్వయంగా తెలిపిన స్కోర్లు; BIG CHANGE చేసిన కొలతలు కావు, మీ హార్డ్‌వేర్ throughputను లేదా ప్రాజెక్ట్ ఫలితాలను అంచనా వేయవు.

ప్రచురణ వేదికల మధ్య విడుదలకు సంబంధించిన ఒక వివరము మారింది. అక్టోబర్ 8న JetBrains విడుదల పోస్ట్ GGUF builds “త్వరలో వస్తాయి” అని చెప్పింది. అక్టోబర్ 9న అధికారిక Hugging Face GGUF రిపాజిటరీ అందుబాటులో ఉంది; అందులో llama.cpp, Ollama తదితర quickstartలు ఉన్నాయి. ఈ మార్గదర్శిని ప్రస్తుతం ప్రచురితమైన GGUF రిపాజిటరీని ఉపయోగిస్తుంది. BF16 రిపాజిటరీ వేరే artifactగానే ఉంది; ఈ దశలను మళ్లీ అనుసరించే ముందు రెండు రిపాజిటరీల్లో మార్పులు ఉన్నాయో చూడండి.

పెద్ద మార్పు

quantized Mellum2.1 build కోసం ప్రచురించిన llama.cpp quickstartను ఇప్పుడు అనుసరించి, స్థానిక OpenAI-compatible endpoint ద్వారా దానికి ప్రశ్నలు పంపవచ్చు. BF16 రిపాజిటరీ కోసం inference-provider deploymentపై ఆధారపడకుండా, స్వయంగా host చేసిన inferenceను మొదటిసారి పరీక్షించడం దీనితో సాధ్యమవుతుంది. ప్రతిస్పందన serving మార్గం పనిచేస్తోందని మాత్రమే చూపుతుంది; agent నాణ్యత, సరిపోవడం, మొత్తం toolchainలో గోప్యత లేదా productionకు సిద్ధతను కాదు.

మూలాలు, మరింత చదవడానికి