VPSలో Claude Code మెమరీ కోసం Recall సెటప్

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

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

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

జూలై 2026 నాటికి Recall version 0.4.0 ప్రస్తుత version, మరియు ఈ project MIT license కింద విడుదలైంది. ఇది ఒక plugin. ఇందులో network call చేసే ఏ భాగమూ లేదు.

VPSలో మీకు అవసరమైనవి

Recall యొక్క capture hooks pluginతో విడుదలయ్యే Python scripts. మూడవ పక్ష 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 optional acceleratorగా పనిచేస్తుంది. అది మీకు అవసరం లేదు.

python3 -c "import numpy"

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

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

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

Claude Code సెషన్‌లో టైప్ చేయాల్సిన రెండు కమాండ్‌లు:

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

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

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

/recall:show

/recall:show ప్రస్తుత సారాంశాన్ని చూపుతుంది. పూర్తిగా కొత్త projectలో చూపించడానికి ఇంకా ఏమీ ఉండదు. కాబట్టి మీరు వాస్తవంగా తనిఖీ చేస్తున్నది ఆ కమాండ్ అసలు ఉందో లేదో. Claude Code /recall:showను గుర్తించకపోతే, plugin లోడ్ కాలేదు. అందువల్ల ఏ 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 సక్రమంగా రూపొందించబడిందో లేదో తెలియజేస్తుంది. తర్వాత claude --plugin-dir ~/recallతో మీ project directory నుంచి 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/

అందులో contentతో కూడిన history.md కనిపించాలి. context.md ఏదీ కనిపించకపోవచ్చు. ఇది లోపం కాదు; ఇదే default behaviour. 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ను కూడా పిలవదు. అందువల్ల ఈ దశకు ఖర్చు ఉండదు మరియు machine offlineలో ఉన్నప్పటికీ పనిచేస్తుంది.

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

కాన్ఫిగరేషన్ ప్రాజెక్ట్ రూట్‌లోని 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 లాగ్‌ను ఆన్ లేదా ఆఫ్ చేస్తుంది.
• auto_save_context off లేదా on_end ను అంగీకరిస్తుంది. డిఫాల్ట్‌గా off ఉంటుంది.
• summary_sentences లోని ఎన్ని వాక్యాలు context.md లో కొనసాగాలో నిర్దేశిస్తుంది. దీన్ని పెంచితే సారాంశం పొడవుగా ఉంటుంది. సెషన్ ప్రారంభంలో లోడ్ కొద్దిగా పెరుగుతుంది.
• redact ఏదైనా డిస్క్‌లో రాయడానికి ముందు సాధారణ రహస్య నమూనాలను తొలగిస్తుంది.
• include_git ప్రస్తుత diff మరియు ఇటీవలి commits ను సారాంశానికి జోడిస్తుంది.
• max_input_chars ప్రతి pass లో summarizer చదివే history.md పరిమాణానికి గరిష్ఠ పరిమితిని విధిస్తుంది.

VPS పై ఉన్న ప్రాజెక్ట్‌కు ఉపయోగకరమైన మార్పు automatic saving ను ప్రారంభించడం. Server లో terminal మూసివేయబడినప్పుడు సెషన్ తరచుగా మీరు ఆపాలని నిర్ణయించినందుకు కాకుండా ముగుస్తుంది.

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

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

touch .recall/.capture-paused

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

Recall టోకెన్లలో ఎంత ఆదా చేస్తుంది?

ప్రత్యామ్నాయం ఏమిటో బట్టి ఇది మారుతుంది. సెషన్ ప్రారంభంలో సారాంశాన్ని లోడ్ చేయడం తక్కువ ఖర్చుతో కూడుకున్నది. అది భర్తీ చేసే ప్రక్రియ ఖరీదైనది కావచ్చు. ప్రాజెక్ట్ గురించి జ్ఞాపకం లేని మోడల్ ఫైళ్లను చదివి ప్రాజెక్ట్‌ను మళ్లీ అర్థం చేసుకుంటుంది.

[
  {
    "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"
  }
]

ఇవి మధ్యస్థ పరిమాణం గల ప్రాజెక్ట్‌కు సాధారణ అంచనాలు మాత్రమే. ఇవి మీ ప్రాజెక్ట్‌లో చేసిన కొలతలు కావు. Recall సారాంశం సుమారుగా 1,200 టోకెన్ల వద్ద లోడ్ అవుతుంది. ఇది resume కోసం ఒకటి నుంచి రెండు వేల టోకెన్లు అవసరమని ప్రాజెక్ట్ ప్రచురించిన వాదనకు అనుగుణంగా ఉంటుంది. మునుపటి పూర్తి transcript‌ను మళ్లీ ప్లే చేస్తే మొత్తం సంభాషణ మళ్లీ లోడ్ అవుతుంది. ఇది సుమారుగా 85,000 టోకెన్ల పరిధిలో ఉంటుంది. ఫైళ్లను చదివి మోడల్ ప్రాజెక్ట్‌ను మళ్లీ అర్థం చేసుకోవడం ఈ రెండింటి మధ్యలో ఉంటుంది. ఇది సుమారుగా 30,000 టోకెన్లకు చేరుతుంది. Repository పెరిగే కొద్దీ ఈ సంఖ్య కూడా పెరుగుతుంది. పరిమాణాన్ని అర్థం చేసుకోవడానికి CLAUDE.md వరుసను చూపించారు. అది చిన్నది మరియు స్థిరమైనది కాబట్టి తక్కువ ఖర్చుతో ఉంటుంది. అలాగే, గత రాత్రి జరిగిన విషయాల బదులు మీ శాశ్వత నియమాలను మోడల్‌కు తెలియజేస్తుంది.

మీ స్వంత సంఖ్యలను కొలవండి. ఇంగ్లీష్ గద్యంలోని ఒక టోకెన్ సుమారుగా నాలుగు అక్షరాలకు సమానం. కోడ్‌కు ఇది కొంచెం తక్కువగా ఉండవచ్చు.

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

సెషన్‌లో ప్రస్తుతం context window‌లో లోడ్ అయిన విషయాన్ని /context చూపిస్తుంది. సెషన్ మొత్తాలను /cost నివేదిస్తుంది. ఒక సెషన్‌ను ఖాళీ స్థితి నుంచి ప్రారంభించండి. తదుపరి సెషన్‌ను సారాంశం ముందుగానే ఉంచి ప్రారంభించండి. ఆ తర్వాత రెండింటినీ పోల్చండి. సెషన్ టోకెన్లు వాస్తవంగా ఎక్కడ ఖర్చవుతున్నాయో పూర్తిగా తెలుసుకోవడానికి Claude Code టోకెన్లను ఎలా ఖర్చు చేస్తుంది అనే విభాగంలో వివరాలు ఉన్నాయి.

ఈ వాదనను వాస్తవికంగా ఉంచే ఒక పరిమితి ఉంది. ప్రతి సెషన్ ప్రారంభంలో సారాంశం లోడ్ అవుతుంది. కాబట్టి మీరు ఉపయోగించని సారాంశం ఆదా కాకుండా చిన్న అదనపు ఖర్చుగా మారుతుంది. మీ సెషన్లు ఎక్కువసేపు నడవకపోతే summary_sentences ను డిఫాల్ట్ విలువకు సమీపంలో ఉంచండి.

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

మీరు repositoryని clone చేసి ఉంటే, summarizerకి స్వంత command line entry point ఉంటుంది. terminalతో పాటు session ముగిసిపోయినప్పుడు, అయినా digest కావాలంటే 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 అనేది మద్దతు ఉన్న మార్గం.

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

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

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

Files తప్పు project కింద కనిపిస్తున్నాయి. Claude Code ప్రారంభించిన directoryకి సంబంధించి Recall వ్రాస్తుంది. అందువల్ల 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 అమలు చేసి, కొత్త history.md సృష్టించబడిందో నిర్ధారించడానికి ls -la .recall/ను మళ్లీ తనిఖీ చేయండి.

Recall ఆగే చోటు

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

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

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

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

summary ను ఉద్దేశపూర్వకంగా నమ్మదగని input గా పరిగణిస్తారు. context.md fenced మరియు label చేయబడిన రూపంలో inject అవుతుంది. దానిపై ఆధారపడే ముందు Claude అడుగుతుంది. Commit చేసిన .recall/ directory లో commit access ఉన్న ఎవరైనా agent చదివే text ను రాయగలరు. అందుకే ఈ విధానం అవసరం. .recall/ వ్యక్తిగతమా లేదా shared దా అనేది ఒకసారి నిర్ణయించండి. వ్యక్తిగత memory కోసం దాన్ని .gitignore కు add చేయండి. లేదా దాన్ని commit చేసి, ఇతర contributions లాగే review చేయండి. agent unattended గా నడిస్తే, VPS లో Claude Code ను సురక్షితంగా నడపడం విస్తృత భద్రతా పరిమితుల గురించి వివరిస్తుంది.

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

Version number దాని maturity స్థాయిని స్పష్టంగా చూపిస్తుంది. July 2026 లో version 0.4.0 ఉన్నందున, releases మధ్య config keys మరియు file layout ఇంకా మారవచ్చు. అందువల్ల మీరు ఆధారపడే 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 నడిపినప్పుడు మాత్రమే summary మళ్లీ రూపొందుతుంది. ప్రతి session ముగిసినప్పుడు దాన్ని మళ్లీ రాయాలంటే recall.config.jsonలో "auto_save_context": "on_end" సెట్ చేయండి. history.md కూడా కనిపించకపోతే hooks అసలు నడవడం లేదు. /recall:showతో plugin load అయిందో నిర్ధారించండి. తర్వాత ఆ boxలో 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 ఉపయోగించి మీ స్వంత గణాంకాలను కొలవండి. Cold startను summary నుంచి resume అయ్యే 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 ప్రారంభించండి. ఎందుకంటే files user accountను కాకుండా working directoryని అనుసరిస్తాయి.