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

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

Recall అనేది Claude Code ప్లగిన్, ఇది ప్రతి ప్రాజెక్ట్‌కు సెషన్ల మధ్య మెమరీని అందిస్తుంది. ఇది మీ ప్రాజెక్ట్‌లోని .recall/ ఫోల్డర్‌లో రెండు మార్క్‌డౌన్ ఫైళ్లను రాస్తుంది: జరిగిన వాటికి సంబంధించిన ఒక append-only లాగ్ మరియు మీరు ఎక్కడ ఆపారో తెలిపే ఒక చిన్న సారాంశం. ఇవి రెండూ మీరు పని చేస్తున్న మెషీన్‌లోనే స్థానిక Python సమ్మరైజర్ ద్వారా రూపొందించబడతాయి, కాబట్టి ఈ మెమరీ కోసం ఎటువంటి API టోకెన్లు ఖర్చు కావు.

ఇది పూరించే లోటు చిన్నది మరియు స్థిరమైనది. మీరు మంగళవారం మీ VPSలో ఒక సెషన్‌ను ముగించారు. బుధవారం, ఒక కొత్త సెషన్ మంగళవారం నాటి సంభాషణను ఆటోమేటిక్‌గా లోడ్ చేయదు, అయితే Claude Code యొక్క అంతర్నిర్మిత ఆటో మెమరీ సెషన్ల మధ్య నోట్స్‌ను నిలుపుకోగలదు. ఒకవేళ ఆ నోట్స్ మీరు ఎక్కడ ఆపారో ఆ విషయాన్ని కవర్ చేయకపోతే, మీరు ప్రాజెక్ట్ గురించి మళ్లీ మాన్యువల్‌గా వివరించాలి, లేదా మోడల్ విషయాన్ని అర్థం చేసుకోవడానికి రిపోజిటరీలో సగం భాగాన్ని మళ్లీ చదివేలా చేయాలి. ఈ రెండు పద్ధతులకు టోకెన్లు ఖర్చవుతాయి, రెండో పద్ధతికి చాలా ఎక్కువ టోకెన్లు ఖర్చవుతాయి.

Recall వెర్షన్ 0.4.0, 18 జూలై 2026న విడుదల చేయబడింది, ఇది అక్టోబర్ 2026 నాటికి కూడా తాజా విడుదలగా ఉంది, మరియు ఈ ప్రాజెక్ట్ MIT లైసెన్స్‌ను కలిగి ఉంది. ఇది ఒక ప్లగిన్. ఇందులో నెట్‌వర్క్ కాల్ చేసే అంశం ఏదీ లేదు.

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 ను నమోదు చేస్తుంది. ప్రతి ఒక్కటి plugin డైరెక్టరీ నుండి ఒక Python script ను రన్ చేస్తుంది.

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

దీని నుండి రెండు ఫైళ్లు వస్తాయి, రెండూ .recall/ లోపల ఉంటాయి.

• history.md అనేది కేవలం జోడించబడే (append-only) రికార్డు: prompts, ప్రతిస్పందనలు, తాకిన ఫైళ్లు మరియు రన్ చేసిన కమాండ్లు.
• context.md అనేది రూపొందించబడిన digest: లక్ష్యం, సారాంశం, తదుపరి దశలు, తాకిన ఫైళ్లు, రన్ చేసిన కమాండ్లు మరియు git context.

ఒక నిజమైన session తర్వాత, డైరెక్టరీని చూడండి.

ls -la .recall/

Capture ఎనేబుల్ చేయబడి, pause marker లేనప్పుడు మరియు transcript అందుబాటులో ఉన్నప్పుడు, మీరు history.md లో కంటెంట్‌ను చూడాలి. మీకు context.md అస్సలు కనిపించకపోవచ్చు, ఇది లోపం కాదు, డిఫాల్ట్ ప్రవర్తన. మీరు సెట్ చేయకపోతే auto_save_context అనేది off గా ఉంటుంది, కాబట్టి మీరు అడిగినప్పుడు మాత్రమే సారాంశం వ్రాయబడుతుంది:

/recall:save

ఆ కమాండ్ history.md పై లోకల్ summarizer ను రన్ చేసి context.md ను తిరిగి వ్రాస్తుంది. ఈ అల్గారిథమ్ TF-IDF (term frequency, inverse document frequency) స్కోరింగ్‌ను TextRank వాక్య ర్యాంకింగ్‌కు అందిస్తుంది. ఇది నిర్ణయాత్మకమైనది (deterministic) మరియు సంగ్రహణాత్మకమైనది (extractive), అంటే ఇది మీ log లో ఇప్పటికే ఉన్న వాక్యాలను ఎంచుకుంటుంది. ఎటువంటి మోడల్ కాల్ చేయబడదు, కాబట్టి ఈ దశ ఉచితం మరియు మెషిన్ ఆఫ్‌లైన్‌లో ఉన్నప్పుడు కూడా పనిచేస్తుంది.

ఒక ప్రాజెక్ట్ కోసం 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 లో ఎన్ని వాక్యాలు నిల్వ ఉండాలో నిర్ణయిస్తుంది. దీన్ని పెంచడం వల్ల సారాంశం (summary) పెద్దదిగా వస్తుంది మరియు సెషన్ ప్రారంభంలో లోడ్ కొంచెం పెరుగుతుంది.
• redact అనేది డిస్క్‌లో ఏది రాయకముందే సాధారణ రహస్య సమాచార (secret) పద్ధతులను తొలగిస్తుంది.
• include_git అనేది ప్రస్తుత diff గణాంకాలను మరియు ఇటీవలి commits ను సారాంశానికి జోడిస్తుంది.
• max_input_chars అనేది ఒకేసారి summarizer ఎంత history.md ని చదవాలో పరిమితిని విధిస్తుంది.

VPS లోని ప్రాజెక్ట్ కోసం ఆటోమేటిక్ సేవింగ్ ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే మీరు సెషన్‌ను ఆపాలని నిర్ణయించుకున్నప్పుడు కాకుండా, టెర్మినల్ క్లోజ్ అయినప్పుడు సర్వర్‌లోని సెషన్ తరచుగా ముగుస్తుంది.

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

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

touch .recall/.capture-paused

ప్రొడక్షన్ క్రెడెన్షియల్స్‌తో పనిచేసే సెషన్‌కు ముందు ఇలా చేయండి, ఎందుకంటే redaction అనేది ఒక ఫిల్టర్ మాత్రమే, అది పూర్తి భద్రతకు హామీ కాదు. సాధారణంగా AI ఏజెంట్లకు రహస్యాలు తెలియకుండా ఉంచడం వెనుక ఉన్న కారణం కూడా ఇదే: ఏజెంట్ ఎప్పటికీ చూడని రహస్యమే అత్యంత సురక్షితమైనది.

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

ఇది దేనితో పోలుస్తున్నారనే దానిపై ఆధారపడి ఉంటుంది. సెషన్ ప్రారంభంలో సారాంశాన్ని (summary) లోడ్ చేయడం తక్కువ ఖర్చుతో కూడుకున్నది. ఇది దేని స్థానంలో వస్తుందో అది ఖరీదైనది కావచ్చు, ఎందుకంటే మీ ప్రాజెక్ట్ గురించి ఏమీ తెలియని మోడల్, ఫైళ్లను చదవడం ద్వారా దానిని తిరిగి అర్థం చేసుకోవాల్సి ఉంటుంది.

[
  {
    "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 కోసం ఒకటి నుండి రెండు వేల టోకెన్లు అవసరమనే ప్రాజెక్ట్ యొక్క వాదనతో సరిపోలుతుంది. మునుపటి పూర్తి ట్రాన్స్‌క్రిప్ట్‌ను మళ్లీ ప్లే చేయడం వల్ల మొత్తం సంభాషణ మళ్లీ లోడ్ అవుతుంది, ఇది సుమారు 85,000 టోకెన్ల పరిధిలో ఉంటుంది. ఫైళ్లను చదవడం ద్వారా మోడల్ ప్రాజెక్ట్‌ను తిరిగి కనుగొనేలా చేయడం ఈ రెండింటి మధ్య, సుమారు 30,000 టోకెన్ల వద్ద ఉంటుంది, మరియు ఈ సంఖ్య రిపోజిటరీ పెరిగేకొద్దీ పెరుగుతుంది. CLAUDE.md వరుస స్కేల్ కోసం ఉద్దేశించబడింది: ఇది తక్కువ ఖర్చుతో కూడుకున్నది ఎందుకంటే ఇది చిన్నది మరియు స్థిరమైనది, అంతేకాకుండా ఇది నిన్న రాత్రి ఏమి జరిగిందో చెప్పే బదులు, మీ ప్రామాణిక నియమాలను మోడల్‌కు తెలియజేస్తుంది.

మీ స్వంత సంఖ్యలను కొలవండి. ఒక టోకెన్ సుమారు నాలుగు ఆంగ్ల అక్షరాలకు సమానం, కోడ్ విషయంలో ఇది కొంచెం తక్కువగా ఉంటుంది. మీరు అదే VPSలో స్థానిక మోడల్‌కు సారాంశాన్ని అందిస్తుంటే, resumeను నమ్మే ముందు అది ఏ విండోలో పడుతుందో తనిఖీ చేయండి, ఎందుకంటే Ollama యొక్క డిఫాల్ట్ కాంటెక్స్ట్ పొడవు అందుబాటులో ఉన్న VRAMపై ఆధారపడి ఉంటుంది.

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

ఒక సెషన్ లోపల, /context ప్రస్తుతం కాంటెక్స్ట్ విండోలోకి ఏమి లోడ్ చేయబడిందో చూపుతుంది, మరియు /cost సెషన్ మొత్తాలను తెలియజేస్తుంది. ఒక సెషన్‌ను కొత్తగా ప్రారంభించండి, మరొక సెషన్‌ను సారాంశంతో ప్రారంభించి పోల్చి చూడండి. ఒక సెషన్ యొక్క టోకెన్లు వాస్తవానికి ఎక్కడ ఖర్చవుతున్నాయో పూర్తి చిత్రాన్ని పొందడానికి, Claude Code టోకెన్లను ఎలా ఖర్చు చేస్తుంది అనే విభాగంలో వివరాలను చూడండి.

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

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

మీరు 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 అనేది మద్దతు ఉన్న మార్గం.

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

పూర్తి సెషన్ తర్వాత .recall/ డైరెక్టరీ ఉండదు. క్యాప్చర్ డిసేబుల్ చేయబడిందా, అవుట్‌పుట్ డైరెక్టరీ వేరే చోట కాన్ఫిగర్ చేయబడిందా, లేదా ట్రాన్స్‌క్రిప్ట్ ఏదీ దొరకలేదా అని తనిఖీ చేయండి. హుక్స్ రన్ కాలేదని నిర్ధారించుకునే ముందు వీటిని చూడండి. ప్లగిన్ లోడ్ అయిందో లేదో నిర్ధారించుకోవడానికి /recall:show టైప్ చేయండి, ఆపై python3 -V రన్ చేయండి. హుక్ కమాండ్ మొదట python3 ను, రెండవదిగా python ను ప్రయత్నిస్తుంది, కాబట్టి ఈ రెండూ లేని బాక్స్‌లో అది విఫలమై stderr మరియు ఎగ్జిట్ స్టేటస్ 127 ను చూపిస్తుంది. Claude Code ఒక నాన్-బ్లాకింగ్ హుక్ ఎర్రర్ నోటీసును చూపిస్తుంది, అందులో stderr యొక్క మొదటి లైన్ ఉంటుంది.

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

ఫైళ్లు తప్పు ప్రాజెక్ట్‌లో కనిపిస్తాయి. Claude Code ప్రారంభించిన డైరెక్టరీకి సంబంధించి Recall ఫైళ్లను రాస్తుంది, కాబట్టి మీ హోమ్ డైరెక్టరీ నుండి సెషన్‌ను ప్రారంభిస్తే మెమరీ అక్కడే సేవ్ అవుతుంది. ప్రాజెక్ట్ రూట్ నుండి ప్రారంభించండి మరియు ఫైళ్లు వాస్తవానికి ఎక్కడ ఉన్నాయో కనుగొనడానికి ls -la .recall/ ఉపయోగించండి.

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

సుదీర్ఘ సెషన్ తర్వాత సారాంశం తక్కువగా ఉంటుంది. max_input_chars సమ్మరైజర్ ఇన్‌పుట్‌ను 200000 క్యారెక్టర్ల వద్ద పరిమితం చేస్తుంది, కాబట్టి చాలా పొడవైన లాగ్ కత్తిరించబడుతుంది. దాన్ని రొటేట్ చేయండి.

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

ఆ తర్వాత ఒక చిన్న సెషన్‌ను రన్ చేయండి మరియు కొత్త history.md కనిపించిందో లేదో నిర్ధారించుకోవడానికి మళ్ళీ ls -la .recall/ ను తనిఖీ చేయండి.

Recall ఎక్కడ ఆగిపోతుంది

Recall అనేది ఒక లాగ్ మరియు సమ్మరైజర్. ఇది దేనిని వదిలివేస్తుందో స్పష్టంగా తెలుసుకోవడం ముఖ్యం.

సమ్మరైజర్ అనేది ఎక్స్‌ట్రాక్టివ్ (extractive) పద్ధతిలో పనిచేస్తుంది. TextRank అనేది ఇప్పటికే history.md లో ఉన్న వాక్యాలను ఎంచుకుంటుంది, కాబట్టి ఒక నిర్ణయం సరైనదా కాదా అని అది ఎప్పుడూ విశ్లేషించదు. మంగళవారం తీసుకున్న తప్పుడు నిర్ణయం, బుధవారం తీసుకున్న మంచి నిర్ణయం లాగే కనిపిస్తుంది. విషయాలు కీలకమైనప్పుడు, context.md ని చదివి, స్వయంగా సరిదిద్దండి. ఇది ఒక markdown ఫైల్, కాబట్టి మీరు దీన్ని ఎడిట్ చేయడానికి ఎటువంటి ఆటంకం లేదు.

ఇందులో సెర్చ్ సదుపాయం లేదు. ప్రతి ప్రాజెక్ట్‌కు ఒక ప్రస్తుత సమ్మరీ మరియు పెరుగుతున్న లాగ్ మాత్రమే లభిస్తాయి; ప్రాజెక్ట్‌ల మధ్య వెతకగలిగే మెమరీ ఉండదు. మూడు వారాల క్రితం డేటాబేస్ గురించి మీరు ఏమి నిర్ణయించుకున్నారో తెలుసుకోవాలంటే, మీరు history.md లో grep చేయాల్సి ఉంటుంది. ఇది లైవ్ కోఆర్డినేషన్‌ను అందించదు: ఒకే ప్రాజెక్ట్‌లోని రెండు సెషన్‌లు లాగ్ ఫైల్‌ను పంచుకుంటాయి, కానీ Recall కొత్త లాగ్ ఎంట్రీలను మరొక సెషన్ కాంటెక్స్ట్‌లోకి పంపదు. కాబట్టి, ఒక సెషన్ మరొకటి ఏమి చేస్తుందో తెలుసుకోవాలనుకున్నప్పుడు, సెషన్‌లు నేరుగా తమ మధ్య టెక్స్ట్‌ను పంపుకోవచ్చు.

ఇది సెషన్ మధ్యలో సహాయపడదు. సెషన్ మధ్యలో కాంటెక్స్ట్ విండో నిండిపోవడం అనేది వేరే సమస్య, దానికి వేరే పరిష్కారాలు ఉంటాయి. ఒక సెషన్ లోపల కాంటెక్స్ట్ విండోను నిర్వహించడం అనేది ఈ గైడ్‌కు అనుబంధంగా ఉంటుంది.

సమ్మరీని డిజైన్ పరంగానే నమ్మదగని ఇన్‌పుట్‌గా పరిగణిస్తారు. context.md ని ఫెన్స్ చేసి, లేబుల్ చేసి పంపుతారు, దానిపై ఆధారపడే ముందు Claude అనుమతి అడుగుతుంది. ఈ డిజైన్ ఎందుకంటే, కమిట్ చేయబడిన .recall/ డైరెక్టరీలో కమిట్ యాక్సెస్ ఉన్న ఎవరైనా మీ ఏజెంట్ చదివే టెక్స్ట్‌ను రాయవచ్చు. ఏజెంట్ తాను చదివిన దాని గురించి ఎంతవరకు అడుగుతుందనేది సెషన్ ప్రారంభమయ్యే పర్మిషన్ మోడ్‌పై ఆధారపడి ఉంటుంది. Claude Code v2.1.283 లేదా ఆ తర్వాత వెర్షన్లలో, auto mode అనేది ఇంటరాక్టివ్ టెర్మినల్ మరియు VS Code సెషన్‌లకు డిఫాల్ట్‌గా ఉంటుంది. కాబట్టి, మీరు కాకుండా ఒక క్లాసిఫైయర్ చాలా చర్యలను సమీక్షిస్తుంది; HIPAA కాన్ఫిగరేషన్ ఉన్న సంస్థలు ఇప్పటికీ Manual మోడ్‌లోనే ప్రారంభమవుతాయి. .recall/ అనేది వ్యక్తిగతమా లేదా భాగస్వామ్యమా అని ఒకసారి నిర్ణయించుకోండి: వ్యక్తిగత మెమరీ కోసం దీన్ని .gitignore కి జోడించండి, లేదా ఇతర కంట్రిబ్యూషన్ల వలె కమిట్ చేసి సమీక్షించండి. ఏజెంట్ పర్యవేక్షణ లేకుండా నడుస్తుంటే, Claude Code ను VPS లో సురక్షితంగా రన్ చేయడం అనే అంశం విస్తృతమైన భద్రతా పరిమితులను వివరిస్తుంది.

రెడాక్షన్ (Redaction) అనేది ఉత్తమ ప్రయత్నం మాత్రమే. ఇది API keys, tokens, PEM blocks మరియు .env అసైన్‌మెంట్‌ల వంటి సాధారణ పద్ధతులను లక్ష్యంగా చేసుకుంటుంది. మీరు కమిట్ చేసే ముందు .recall/ ని చదవండి.

వెర్షన్ నంబర్ దాని పరిణతిని నిజాయితీగా తెలియజేస్తుంది. అక్టోబర్ 2026 నాటికి 0.4.0 అనేది తాజా రిలీజ్. కాన్ఫిగరేషన్ కీలు మరియు ఫైల్ లేఅవుట్ రిలీజ్‌ల మధ్య మారవచ్చు, కాబట్టి మీరు ఆధారపడే సెటప్‌ను అప్‌గ్రేడ్ చేసే ముందు changelog ని చదవండి.

FAQ

Recall నా కోడ్‌ను లేదా ట్రాన్స్‌క్రిప్ట్‌లను ఎక్కడికైనా పంపుతుందా?

లేదు. Capture hooks మరియు summarizer అనేవి మీ సొంత మెషీన్‌లో నడిచే Python స్క్రిప్ట్‌లు. ఈ ప్లగిన్ వద్ద ఎటువంటి API key ఉండదు మరియు ఇది ఎటువంటి నెట్‌వర్క్ కాల్‌లను చేయదు. సారాంశాన్ని (summarising) రూపొందించడానికి ఇది ఒక మోడల్‌కు బదులుగా TF-IDF మరియు TextRank పద్ధతులను ఉపయోగిస్తుంది. కాబట్టి, ఈ ప్రక్రియకు ఎటువంటి ఖర్చు ఉండదు మరియు మెషీన్ ఆఫ్‌లైన్‌లో ఉన్నప్పుడు కూడా పనిచేస్తుంది. దీనివల్ల కలిగే పరిమితి ఏమిటంటే, సారాంశం ఎక్స్‌ట్రాక్టివ్ (extractive) పద్ధతిలో ఉంటుంది: అంటే ఇది కొత్త వాక్యాలను రాయడానికి బదులుగా మీ లాగ్ నుండి ఉన్న వాక్యాలను ఎంచుకుంటుంది.

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

auto_save_context డిఫాల్ట్‌గా off కి సెట్ చేయబడి ఉంటుంది, కాబట్టి మీరు /recall:save రన్ చేసినప్పుడు మాత్రమే సారాంశం తిరిగి రూపొందించబడుతుంది. ప్రతి సెషన్ ముగిసినప్పుడు సారాంశం తిరిగి రాయబడాలంటే, recall.config.json లో "auto_save_context": "on_end" ని సెట్ చేయండి. ఒకవేళ history.md కూడా కనిపించకపోతే, capture_history ని, .capture-paused మార్కర్‌ను మరియు సెషన్ ట్రాన్స్‌క్రిప్ట్ అందుబాటులో ఉందో లేదో తనిఖీ చేయండి: అటువంటి సందర్భాల్లో hooks హిస్టరీని రాయడాన్ని స్కిప్ చేస్తాయి. /recall:show తో ప్లగిన్ లోడ్ అయిందో లేదో నిర్ధారించుకోండి, ఆపై hooks అనేవి Python స్క్రిప్ట్‌లు కాబట్టి, ఆ బాక్స్‌లో python3 -V స్పందిస్తుందో లేదో తనిఖీ చేయండి.

ఒక్కో సెషన్‌కు Recall ఎంత సేవ్ చేస్తుంది?

ఒక సారాంశాన్ని లోడ్ చేయడానికి సుమారు 1,200 టోకెన్లు ఖర్చవుతాయి. అదే ఒక మోడల్ మీ రిపోజిటరీని మళ్ళీ చదివి, మీరు ఎక్కడ ఉన్నారో తెలుసుకోవడానికి 30,000 టోకెన్లు ఖర్చవుతాయి. ఇవి సాధారణ అంచనాలు మాత్రమే. సెషన్ మధ్యలో wc -c .recall/context.md మరియు /context కమాండ్‌లను ఉపయోగించి, కోల్డ్ స్టార్ట్ (cold start) మరియు సారాంశం నుండి తిరిగి ప్రారంభించే విధానాలను పోల్చి చూస్తూ మీ స్వంత గణాంకాలను కొలవండి.

నాకు ఇప్పటికీ CLAUDE.md ఫైల్ అవసరమా?

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

ఒకే VPS లో అనేక ప్రాజెక్ట్‌ల మెమరీని ఉంచవచ్చా?

అవును. Recall ప్రతి ప్రాజెక్ట్ డైరెక్టరీలోని .recall/ లో మెమరీని ఉంచుతుంది. కాబట్టి ఒకే సర్వర్‌లోని రెండు ప్రాజెక్ట్‌లు వేర్వేరు లాగ్‌లను మరియు వేర్వేరు సారాంశాలను కలిగి ఉంటాయి. ప్రతిసారీ ప్రాజెక్ట్ రూట్ నుండి Claude Code ని ప్రారంభించండి, ఎందుకంటే ఫైల్‌లు యూజర్ అకౌంట్‌ను కాకుండా, మీరు పనిచేస్తున్న డైరెక్టరీని అనుసరిస్తాయి.