VPSలో Claude Codeకు Recall memory ఎలా ఇవ్వాలి

Claude Code memory కోసం Recall ఏమి చేస్తుంది

Recall అనేది ప్రతి project కు sessions మధ్య memory అందించే Claude Code plugin. ఇది మీ project లోని .recall/ folder లో రెండు markdown files రాస్తుంది: జరిగిన విషయాల append-only log ఒకటి, మీరు ఎక్కడ పని ఆపారో తెలిపే సంక్షిప్త summary మరొకటి. మీరు పని చేస్తున్న machine పైనే local Python summarizer ఈ రెండింటినీ రూపొందిస్తుంది. అందువల్ల memory కోసం API tokens ఖర్చు కావు.

ఇది పరిష్కరించే అంతరం చిన్నదే అయినా నిరంతరం ఉంటుంది. మీరు మంగళవారం మీ VPS పై session ను ముగిస్తారు. బుధవారం Claude Code కు మంగళవారం జరిగిన విషయాల గురించి ఏమీ తెలియదు. మీరు project ను చేతితో మళ్లీ వివరిస్తారు, లేదా model ను repository లో సగభాగాన్ని మరోసారి చదివి అర్థం చేసుకోనిస్తారు. రెండింటికీ tokens ఖర్చవుతాయి. రెండవ విధానానికి చాలా tokens ఖర్చవుతాయి.

July 2026 నాటికి Recall version 0.4.0 ప్రస్తుత version, మరియు project MIT licensed. ఇది ఒక plugin. ఇందులో ఏదీ network call చేయదు.

VPSలో అవసరమైనవి

Recall capture hooks అనేవి plugin తో విడుదలయ్యే Python scripts. వీటికి third-party dependencies ఏవీ లేవు. కాబట్టి నిజమైన ఏకైక అవసరం interpreter.

python3 -V

Ubuntu 24.04 దీనికి Python 3.12.3 సమాధానం ఇస్తుంది. Recall Python 3.9 మరియు తదుపరి versions కు మద్దతు ఇస్తుంది. Minimal container images లో కొన్నిసార్లు interpreter అసలు ఉండదు. అప్పుడు shell python3: command not found సమాధానం ఇస్తుంది. ముందుకు వెళ్లే ముందు ఒకదాన్ని install చేయండి.

sudo apt update && sudo apt install -y python3

Summarizer లోని ఒక దశను వేగవంతం చేయడానికి NumPy ఐచ్ఛిక accelerator గా ఉపయోగపడుతుంది. అది మీకు అవసరం లేదు.

python3 -c "import numpy"

ఇక్కడ ModuleNotFoundError: No module named 'numpy' సరైన సమాధానం. Summarizer లో pure-Python మార్గం ఉంది. రెండు మార్గాలు ఒకే sentences ను ఎంచుకుంటున్నాయో లేదో project యొక్క test suite తనిఖీ చేస్తుంది.

Laptop కంటే server పై session memory ఎక్కువగా ఉపయోగపడుతుంది. కారణం, server పనులు రోజుల వ్యవధిలో చిన్నచిన్న visits గా వస్తాయి. మీరు ఇప్పటికే VPSలో tmuxలో Claude Code నడుపుతుంటే, నిన్నటి session ను ఈరోజుకు తీసుకువచ్చేది Recall.

plugin marketplace నుంచి Recall ను ఇన్‌స్టాల్ చేయండి

Claude Code session లో టైప్ చేయాల్సిన రెండు commands:

/plugin marketplace add raiyanyahya/recall
/plugin install recall@recall

రెండవ command plugin@marketplace ను చదువుతుంది. ఇక్కడ రెండు పేర్లు recall గానే కనిపిస్తాయి. ఇది copy-paste పొరపాటు కాదు.

Plugin లోని స్వంత commands లో ఒకదాన్ని అమలు చేసి installation ను తనిఖీ చేయండి:

/recall:show

/recall:show ప్రస్తుత summary ను చూపిస్తుంది. పూర్తిగా కొత్త project లో చూపించడానికి ఇంకా ఏమీ ఉండదు. అందువల్ల మీరు వాస్తవంగా తనిఖీ చేసేది command అసలు ఉందా అనేదే. Claude Code /recall:show ను గుర్తించకపోతే plugin load కాలేదు. అప్పుడు ఏ hook కూడా అమలు కాదు.

Checkout నుంచి అమలు చేయాలంటే ముందుగా repository ను clone చేసి, దాన్ని validate చేయండి:

git clone https://github.com/raiyanyahya/recall ~/recall
cd ~/recall && claude plugin validate .

claude plugin validate . .claude-plugin/ లోని manifest ను చదివి plugin సరైన నిర్మాణంలో ఉందో లేదో నివేదిస్తుంది. తరువాత మీ project directory నుంచి claude --plugin-dir ~/recall తో Claude Code ను ప్రారంభించండి.

hooks ఏమి రాస్తాయి, ఎప్పుడు రాస్తాయి

Recall మూడు Claude Code hooks ను నమోదు చేస్తుంది. ప్రతి hook plugin directory నుంచి ఒక Python script ను నడుపుతుంది.

• SessionStart startup, resume మరియు clear సమయంలో నడుస్తుంది. ఇది context.md ను చూపిస్తుంది, కాబట్టి session ప్రారంభమైనప్పుడు మీ summary కనిపిస్తుంది.
• Stop Claude ప్రతి response ను పూర్తి చేసినప్పుడు నడుస్తుంది. ఇది ఆ turn ను log కు జతచేస్తుంది.
• SessionEnd session మూసివేసినప్పుడు నడుస్తుంది. ఇది summary ను మళ్లీ రూపొందించగలదు.

దీని వల్ల రెండు files ఏర్పడతాయి. రెండూ .recall/ లోనే ఉంటాయి.

• history.md append-only record. ఇందులో prompts, responses, మార్చిన files మరియు అమలు చేసిన commands ఉంటాయి.
• context.md generated digest. ఇందులో goal, summary, next steps, మార్చిన files, అమలు చేసిన commands మరియు git context ఉంటాయి.

ఒక నిజమైన session తర్వాత directory ను చూడండి.

ls -la .recall/

history.md లో content కనిపించాలి. context.md అసలు కనిపించకపోవచ్చు. ఇది లోపం కాదు; default behaviour. మీరు దాన్ని set చేయకపోతే auto_save_context అనేది off. అందువల్ల మీరు అడిగినప్పుడు మాత్రమే summary రాయబడుతుంది:

/recall:save

ఈ command history.md పై local summarizer ను నడిపి, context.md ను మళ్లీ రాస్తుంది. Algorithm TF-IDF (term frequency, inverse document frequency) scoring ను TextRank sentence ranking కు అందిస్తుంది. ఇది deterministic మరియు extractive. అంటే మీ log లో ఇప్పటికే ఉన్న sentences ను మాత్రమే ఎంచుకుంటుంది. ఏ model ను పిలవదు. అందువల్ల ఈ step కు ఖర్చు ఉండదు మరియు machine offline లో ఉన్నా పనిచేస్తుంది.

ఒక ప్రాజెక్ట్‌కు Recall ను కాన్ఫిగర్ చేయడం

కాన్ఫిగరేషన్ ప్రాజెక్ట్ root లోని recall.config.json ఫైల్‌లో ఉంటుంది. ఇవి విడుదలతో వచ్చే డిఫాల్ట్‌లు:

{
  "output_dir": ".recall",
  "capture_history": true,
  "summary_sentences": 8,
  "redact": true,
  "include_git": true,
  "max_input_chars": 200000
}

• output_dir రెండు ఫైళ్లు ఎక్కడ ఉండాలో నిర్దేశిస్తుంది. వాటిని ప్రాజెక్ట్‌లోనే ఉంచండి.
• capture_history history.md log ను ఆన్ లేదా ఆఫ్ చేస్తుంది.
• auto_save_context off లేదా on_end ను స్వీకరిస్తుంది. డిఫాల్ట్ విలువ off.
• summary_sentences వాక్యాలు context.md లో నిల్వ ఉండాలో నిర్దేశిస్తుంది. ఈ విలువను పెంచితే summary పొడవుగా ఉంటుంది. session ప్రారంభంలో load కూడా కొద్దిగా పెరుగుతుంది.
• redact ఏదైనా disk కు రాయడానికి ముందు సాధారణ secret నమూనాలను తొలగిస్తుంది.
• include_git ప్రస్తుత diff మరియు ఇటీవలి commits ను summary లో చేర్చుతుంది.
• max_input_chars summarizer ఒక pass లో history.md నుంచి చదివే పరిమాణానికి పరిమితి విధిస్తుంది.

VPS పై ఉన్న ప్రాజెక్ట్‌కు automatic saving ఉపయోగకరమైన మార్పు. ఎందుకంటే server పై session ను మీరు ఆపాలని నిర్ణయించినప్పుడు కాకుండా, terminal మూసుకుపోయినప్పుడు తరచుగా ముగుస్తుంది.

{
  "auto_save_context": "on_end",
  "summary_sentences": 12
}

కాన్ఫిగరేషన్‌ను మార్చకుండా కొంతకాలం capture ఆపాలంటే pause marker ను సృష్టించండి. మళ్లీ capture ప్రారంభించడానికి దాన్ని తొలగించండి.

touch .recall/.capture-paused

Production credentials ను నిర్వహించే session కు ముందు దీన్ని చేయండి. Redaction ఒక filter మాత్రమే; అది పూర్తి హామీ కాదు. సాధారణంగా AI agents కు secrets దూరంగా ఉంచడం వెనుక ఉన్న కారణం కూడా ఇదే: agent ఎప్పుడూ చూడని secret మాత్రమే సురక్షితమైనది.

Recall ద్వారా tokens ఎంతవరకు ఆదా అవుతాయి?

ఇది ప్రత్యామ్నాయం ఏమిటన్నదిపై ఆధారపడి ఉంటుంది. Session ప్రారంభంలో summary ను load చేయడం తక్కువ ఖర్చుతో పూర్తవుతుంది. అది భర్తీ చేసేది ఖరీదైనదై ఉండవచ్చు, ఎందుకంటే మీ project గురించి memory లేని model files చదివి దానిని మళ్లీ అర్థం చేసుకోవాలి.

[
  {
    "label": "Recall context.md",
    "char_count": "4,800",
    "est_tokens": "1,200"
  },
  {
    "label": "Hand-written CLAUDE.md",
    "char_count": "3,200",
    "est_tokens": "800"
  },
  {
    "label": "Re-reading the repo",
    "char_count": "120,000",
    "est_tokens": "30,000"
  },
  {
    "label": "Full transcript replay",
    "char_count": "340,000",
    "est_tokens": "85,000"
  }
]

ఇవి mid-size project కు సంబంధించిన సాధారణ అంచనాలు మాత్రమే; మీ project పై చేసిన కొలతలు కావు. Recall summary ను సుమారు 1,200 tokens తో load చేయవచ్చు. ఇది resume కోసం project ప్రచురించిన one to two thousand tokens అంచనాతో సరిపోతుంది. గత పూర్తి transcript ను మళ్లీ play చేస్తే మొత్తం conversation తిరిగి load అవుతుంది. దానికి సుమారు 85,000 tokens పడతాయి. Files చదివి project ను model మళ్లీ అర్థం చేసుకునే విధానం ఈ రెండింటి మధ్యలో ఉంటుంది. దీనికి సుమారు 30,000 tokens పడతాయి. Repository పెరిగేకొద్దీ ఈ సంఖ్య కూడా పెరుగుతుంది. CLAUDE.md row పరిమాణాన్ని అర్థం చేసుకోవడానికి ఉపయోగపడుతుంది. ఇది చిన్నది, స్థిరమైనది కాబట్టి తక్కువ ఖర్చుతో ఉంటుంది. గత రాత్రి జరిగిన విషయాల బదులు, మీ శాశ్వత నియమాలను model కు తెలియజేస్తుంది.

మీ స్వంత సంఖ్యలను కొలవండి. English prose లో ఒక token సుమారు నాలుగు characters కు సమానం. Code కు ఇది కొద్దిగా తక్కువగా ఉండవచ్చు. అదే VPS లో summary ను local model కు కూడా పంపిస్తే, resume పై ఆధారపడే ముందు అది ఏ context window లోకి వెళ్తుందో పరిశీలించండి. ఎందుకంటే Ollama దీర్ఘమైన prompts ను చిన్న default context length వద్ద truncate చేస్తుంది. Prompt చివరి భాగం తొలగించబడిందని అది తెలియజేయదు.

wc -c .recall/context.md .recall/history.md
echo $(( $(wc -c < .recall/context.md) / 4 ))

Session లో ప్రస్తుతం context window లో load అయి ఉన్నదాన్ని /context చూపిస్తుంది. Session totals ను /cost నివేదిస్తుంది. ఒక session ను ఎలాంటి ముందస్తు data లేకుండా ప్రారంభించండి. తరువాత summary అందుబాటులో ఉన్న స్థితిలో మరో session ప్రారంభించండి. ఆ రెండింటిని పోల్చండి. Session tokens వాస్తవంగా ఎక్కడ ఖర్చవుతున్నాయో పూర్తి వివరాల కోసం Claude Code tokens ను ఎలా ఖర్చు చేస్తుందో చూడండి.

ఈ వాదనను వాస్తవికంగా ఉంచే ఒక పరిమితి ఉంది. ప్రతి session ప్రారంభంలో summary load అవుతుంది. కాబట్టి మీరు ఉపయోగించని summary ఆదా కాకుండా చిన్న అదనపు ఖర్చుగా మారుతుంది. మీ sessions ఎక్కువసేపు నడవకపోతే summary_sentences ను default కు దగ్గరగా ఉంచండి. మరోవైపు session లో తక్కువ output ఉండటం కూడా సహాయపడుతుంది. ఎందుకంటే అవసరమైన అతి చిన్న మార్పు వైపు నడిపించిన agent summarizer కు rank చేయాల్సిన చిన్న log ను వదిలిపెడుతుంది.

సెషన్ లేకుండా సారాంశాన్ని మళ్లీ రూపొందించడం

మీరు repository ను clone చేసి ఉంటే, summarizer కు స్వంత command line entry point ఉంటుంది. terminal తో పాటు session ముగిసిపోయినప్పుడు, summary అయినా కావాలనుకునే VPS సందర్భంలో ఇది ఉపయోగకరంగా ఉంటుంది.

python3 ~/recall/scripts/make_context.py --help

help output ఇది స్వీకరించే flags ను చూపిస్తుంది: project root కోసం --cwd, స్పష్టంగా పేర్కొన్న transcript file కోసం --transcript, output ను అణచివేయడానికి --quiet, అలాగే claude మరియు opencode మధ్య ఎంచుకోవడానికి --harness. దీన్ని project కు సూచించండి:

python3 ~/recall/scripts/make_context.py --cwd /srv/projects/api

ఇది session transcript ను చదివి history.md చేస్తుంది. తరువాత మీరు ఇచ్చిన directory కింద context.md ను రాస్తుంది. మీరు marketplace ద్వారా install చేసి ఉంటే, plugin ను Claude Code నిర్వహించే directory లో ఉంచుతుంది. అదే పని చేయడానికి /recall:save అనేది మద్దతు ఉన్న మార్గం.

ఏదీ రాయబడకపోవడానికి కారణాలు

పూర్తి session తర్వాత .recall/ directory లేదు. Hooks ఎప్పుడూ run కాలేదు. Plugin load అయిందో లేదో నిర్ధారించడానికి /recall:show టైప్ చేయండి. తరువాత python3 -V run చేయండి. Hook command ముందుగా python3 ను, తరువాత python ను ప్రయత్నిస్తుంది. రెండూ లేని box ఏదీ రాయదు. దీనిపై ఎలాంటి సమాచారం కూడా చూపించదు.

history.md పెరుగుతోంది, కానీ context.md లో ఎలాంటి మార్పు లేదు. auto_save_context default గా off గా ఉంటుంది. /recall:save run చేయండి. లేదా key ను on_end కు సెట్ చేసి SessionEnd hook ద్వారా అది చేయనివ్వండి.

Files తప్పు project కింద కనిపిస్తున్నాయి. Claude Code ప్రారంభించిన directory కి అనుసంధానంగా relative paths లో files ను రాస్తుంది. అందువల్ల home directory నుంచి session ప్రారంభిస్తే memory అక్కడే రాయబడుతుంది. Project root నుంచి ప్రారంభించండి. Files వాస్తవంగా ఎక్కడ రాయబడ్డాయో తెలుసుకోవడానికి ls -la .recall/ ఉపయోగించండి.

Capture ఆగిపోయింది, కానీ మీకు ఎలాంటి హెచ్చరిక రాలేదు. ls -a .recall/ తో pause marker ఉందో లేదో పరిశీలించండి. గత వారం మీరు సృష్టించిన .capture-paused file ఇప్పటికీ పనిచేస్తూనే ఉంటుంది.

చాలా సుదీర్ఘమైన session తర్వాత summary లో తక్కువ సమాచారం ఉంది. max_input_chars summarizer input ను 200000 characters కు పరిమితం చేస్తుంది. అందువల్ల చాలా పొడవైన log కత్తిరించబడుతుంది. దాన్ని rotate చేయండి.

mv .recall/history.md .recall/history-2026-07-30.md

తర్వాత ఒక చిన్న session run చేయండి. కొత్త history.md ఏర్పడిందో లేదో నిర్ధారించడానికి మళ్లీ ls -la .recall/ పరిశీలించండి.

Recall నిలిచిపోయే చోటు

Recall ఒక log మరియు summarizer. అందువల్ల అది ఏ విషయాలను కవర్ చేయదో స్పష్టంగా తెలుసుకోవాలి.

Summarizer extractive విధానాన్ని ఉపయోగిస్తుంది. TextRank ఇప్పటికే history.md లో ఉన్న వాక్యాలను ఎంచుకుంటుంది. అందువల్ల ఏ నిర్ణయం సరైనదో అది నిర్ధారించదు. మంగళవారం నమోదు చేసిన తప్పు నిర్ణయం, బుధవారం నమోదు చేసిన మంచి నిర్ణయం లాగే కనిపిస్తుంది. పరిస్థితి ముఖ్యమైనదైతే context.md చదివి, దాన్ని చేతితో సరిచేయండి. అది markdown file మాత్రమే. దాన్ని edit చేయకుండా ఏదీ మిమ్మల్ని ఆపదు.

Search లేదు. ప్రతి project కు ఒక ప్రస్తుత summary మరియు పెరుగుతున్న ఒక log మాత్రమే ఉంటాయి. Projects అంతటా query చేయగల memory ఉండదు. మూడు వారాల క్రితం database గురించి మీరు ఏమి నిర్ణయించారో తెలుసుకోవాలంటే, మీరు history.md లో grep చేయాలి. ఇది sessions మధ్య సమాచారాన్ని పంచదు. ఒకే VPS పై ఒకేసారి తెరిచి ఉన్న రెండు sessions, ఒకదాని logs ను మరొకటి చూడలేవు. ఒక session మరొకటి ఏం చేస్తుందో తెలుసుకోవాల్సి వస్తే, అవి నడుస్తున్న సమయంలో sessions ఒకదానికొకటి నేరుగా text పంపగలవు.

ఇది session లోపల సహాయపడదు. Session మధ్యలో context window నిండిపోవడం వేరే సమస్య. దానికి వేరే పరిష్కారాలు ఉంటాయి. ఒక session లోపల context window ను నిర్వహించడం ఈ guide కు అనుబంధ అంశం.

Summary ను ఉద్దేశపూర్వకంగా untrusted input గా పరిగణిస్తారు. context.md ను fenced మరియు labelled రూపంలో inject చేస్తారు. దానిపై ఆధారపడే ముందు Claude అడుగుతుంది. ఈ విధానం అవసరమైన కారణం, commit access ఉన్న ఎవరైనా agent చదివే text ను committed .recall/ directory లో రాయగలగడమే. Agent చదివిన విషయాల గురించి ఎంత తరచుగా ప్రశ్నించాలో, session ప్రారంభమయ్యే permission mode నిర్ణయిస్తుంది. అలాగే 14 August 2026 నుండి auto mode Claude Code default అవుతుంది. .recall/ వ్యక్తిగతమా లేదా shared దా అనే నిర్ణయాన్ని ఒకసారి తీసుకోండి. వ్యక్తిగత memory కోసం దాన్ని .gitignore కు add చేయండి. లేదా దాన్ని commit చేసి, ఇతర contribution లాగే review చేయండి. Agent unattended గా నడిస్తే, VPS పై Claude Code ను సురక్షితంగా నడపడం విస్తృత boundary గురించి వివరిస్తుంది.

Redaction best effort ఆధారంగా పనిచేస్తుంది. ఇది API keys, tokens, PEM blocks మరియు .env assignments వంటి సాధారణ patterns ను లక్ష్యంగా చేసుకుంటుంది. దాన్ని commit చేసే ముందు .recall/ చదవండి.

Version number maturity గురించి స్పష్టంగా చెబుతుంది. July 2026లో 0.4.0 version వద్ద config keys మరియు file layout releases మధ్య ఇంకా మారవచ్చు. అందువల్ల మీరు ఆధారపడే setup ను upgrade చేసే ముందు changelog చదవండి.

FAQ

Recall నా code లేదా transcripts ను ఎక్కడికైనా పంపుతుందా?

లేదు. Capture hooks మరియు summarizer మీ స్వంత machine పై నడిచే Python scripts. Plugin లో API key ఉండదు, అది ఎటువంటి network call చేయదు. Summarising కోసం model బదులుగా TF-IDF మరియు TextRank ఉపయోగిస్తారు. అందువల్ల ఈ దశకు ఎటువంటి ఖర్చు ఉండదు, machine offline లో ఉన్నా పనిచేస్తుంది. అయితే summary extractive గా ఉంటుంది: కొత్త వాక్యాలు రాయడానికి బదులుగా మీ log నుంచి వాక్యాలను ఎంచుకుంటుంది.

నా .recall/context.md ఎందుకు కనిపించడం లేదు లేదా పాతదిగా ఉంది?

auto_save_context యొక్క default విలువ off. అందువల్ల మీరు /recall:save run చేసినప్పుడు మాత్రమే summary మళ్లీ రూపొందుతుంది. ప్రతి session ముగిసినప్పుడు దాన్ని మళ్లీ రాయాలంటే recall.config.json లో "auto_save_context": "on_end" ను set చేయండి. history.md కూడా కనిపించకపోతే hooks అసలు run కావడం లేదు. /recall:show తో plugin load అయిందో లేదో నిర్ధారించండి. తరువాత ఆ machine లో python3 -V సమాధానం ఇస్తుందో లేదో నిర్ధారించండి, ఎందుకంటే hooks Python scripts.

ప్రతి session కు Recall ఎంత ఆదా చేస్తుంది?

Summary load చేయడానికి సుమారు 1,200 tokens ఖర్చవుతాయి. మీ repository ని మళ్లీ చదివి ప్రస్తుత స్థానం తెలుసుకోవాల్సిన model కు సాధారణంగా 30,000 tokens అవసరం అవుతాయి. ఇవి సాధారణ అంచనాలు మాత్రమే. Session లో wc -c .recall/context.md మరియు /context command ఉపయోగించి మీ స్వంత విలువలను కొలవండి. Summary నుంచి resume చేసే ప్రారంభంతో, cold start ను పోల్చండి.

నాకు ఇంకా CLAUDE.md file అవసరమా?

అవును. ఈ రెండూ వేర్వేరు పనులు చేస్తాయి. CLAUDE.md మీరు ఉద్దేశపూర్వకంగా రాసేది: స్థిరమైన నియమాలు మరియు build commands. context.md గత session లో నిజంగా జరిగిన విషయాల నుంచి రూపొందుతుంది. అందువల్ల మీరు రాసుకోవాలని ఎప్పుడూ అనుకోని, పూర్తికాని migration వివరాలు అందులో ఉంటాయి. రెండింటినీ ఉంచండి.

ఒక VPS అనేక projects కోసం memory ను ఉంచగలదా?

అవును. Recall ప్రతి project directory లోని .recall/ లో memory ను ఉంచుతుంది. అందువల్ల ఒకే server లోని రెండు projects కు వేర్వేరు logs మరియు వేర్వేరు summaries ఉంటాయి. ప్రతిసారి project root నుంచి Claude Code ను start చేయండి. ఎందుకంటే files user account ను అనుసరించవు; అవి working directory ను అనుసరిస్తాయి.