Claude Code രഹസ്യമായി അപ്‌ഗ്രേഡ് ചെയ്തു, ഒടുവിൽ ഒരു "ടെക്സ്റ്റ് സെർച്ച് മെഷീൻ" അല്ലാതായി

നിങ്ങൾ കോഡ് എഴുതുമ്പോൾ, ഒരു ചോദ്യം ചിന്തിച്ചിട്ടുണ്ടോ:

എന്തുകൊണ്ടാണ് VS Code-ൽ Ctrl + ക്ലിക്ക് ചെയ്യുമ്പോൾ ഫംഗ്‌ഷൻ നിർവചനത്തിലേക്ക് നേരിട്ട് പോകാൻ കഴിയുന്നത്? നിങ്ങളുടെ മൗസ് ഒരു ഫംഗ്‌ഷനിൽ ഹോവർ ചെയ്യുമ്പോൾ, പൂർണ്ണമായ പാരാമീറ്റർ വിവരണം കാണാൻ കഴിയുന്നത് എന്തുകൊണ്ട്? നിങ്ങളുടെ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, എവിടെയാണ് തെറ്റ് എന്ന് എഡിറ്റർക്ക് എങ്ങനെ കണ്ടെത്താനാകും?

ഈ ഫീച്ചറുകൾ നിങ്ങൾ ദിവസവും ഉപയോഗിക്കുന്നു, വളരെ സുഖകരമായി തോന്നുന്നു.

എന്നാൽ ഇതിന് പിന്നിൽ LSP (Language Server Protocol) എന്നൊരു കാര്യമാണ് ഉള്ളതെന്ന് നിങ്ങൾക്കറിയില്ലായിരിക്കാം.

കൂടുതൽ പ്രധാനമായി, Claude Code 2.0.74 പതിപ്പ് മുതൽ, LSP പിന്തുണയ്ക്കുന്നു.

ഇതിനർത്ഥമെന്താണ്?

Claude Code ഒടുവിൽ ഒരു "ടെക്സ്റ്റ് സെർച്ച് മെഷീനിൽ" നിന്ന് കോഡിനെ ശരിക്കും മനസ്സിലാക്കുന്ന ഒരു AI ആയി മാറി എന്നാണ് ഇതിനർത്ഥം.

എന്താണ് LSP? ലളിതമായി പറഞ്ഞാൽ

LSP എന്നത് Microsoft ഉണ്ടാക്കിയ ഒരു പ്രോട്ടോക്കോൾ ആണ്, ഇതിൻ്റെ ലക്ഷ്യം വളരെ ലളിതമാണ്:

ഏത് എഡിറ്ററിലും കോഡ് ഇന്റലിജൻസ് ഫീച്ചറുകൾ ഉപയോഗിക്കാൻ അനുവദിക്കുക.

ഇതാ നോക്കൂ:

• TypeScript-ൻ്റെ ലാംഗ്വേജ് സെർവർ, VS Code-ൽ ഉപയോഗിക്കാം, JetBrains-ൽ ഉപയോഗിക്കാം, Cursor-ൽ ഉപയോഗിക്കാം

• ഇപ്പോൾ, Claude Code-ലും ഉപയോഗിക്കാം

LSP എന്നാൽ നിങ്ങളുടെ എഡിറ്ററെ കൂടുതൽ സ്മാർട്ടാക്കുന്ന ഒന്ന്:

• ഫംഗ്ഷൻ നാമങ്ങളും പാരാമീറ്ററുകളും സ്വയം പൂർത്തിയാക്കുക

• നിർവചനത്തിലേക്ക് പോകുക

• എല്ലാ റഫറൻസുകളും കണ്ടെത്തുക

• ഹോവർ ചെയ്യുമ്പോൾ ഡോക്യുമെൻ്റേഷൻ കാണിക്കുക

• തത്സമയം പിശകുകളും മുന്നറിയിപ്പുകളും കാണിക്കുക

നിങ്ങൾ ദിവസവും കോഡ് എഴുതുമ്പോൾ, ഈ ഫീച്ചറുകൾ എണ്ണമറ്റ തവണ ഉപയോഗിക്കുന്നു.

എന്നാൽ ഇത് എങ്ങനെയാണ് പ്രവർത്തിക്കുന്നതെന്ന് നിങ്ങൾ ഒരിക്കലും ചിന്തിച്ചിട്ടില്ല.

ഇനി ചിന്തിക്കേണ്ടതില്ല, ഇത് മാത്രം അറിഞ്ഞിരിക്കുക: Claude Code-നും ഇപ്പോൾ ഈ കഴിവുകളുണ്ട്.

Claude Code എങ്ങനെയാണ് മുമ്പ് പ്രവർത്തിച്ചിരുന്നത്?

LSP പിന്തുണയ്ക്കുന്നതിന് മുമ്പ്, Claude Code ഒരു ഫംഗ്ഷൻ എവിടെയാണ് നിർവചിച്ചിരിക്കുന്നതെന്ന് കണ്ടെത്താൻ ശ്രമിച്ചാൽ, അത് എങ്ങനെ ചെയ്യും?

grep ഉപയോഗിച്ച് തിരയുക.

ലളിതമായി പറഞ്ഞാൽ, അത് ഒരു പൂർണ്ണ ടെക്സ്റ്റ് തിരയലാണ്, "displayBooks" എന്ന ഈ പ്രതീകങ്ങൾ എവിടെയാണ് ദൃശ്യമാകുന്നതെന്ന് കണ്ടെത്തുക.

ഇത് ഉപയോഗിക്കാൻ കഴിയുമോ? ഉപയോഗിക്കാൻ കഴിയും.

AI മോഡലുകൾ വലിയ അളവിലുള്ള കോഡുകൾ പരിശീലിപ്പിച്ചിട്ടുണ്ട്, അതിനാൽ ടെക്സ്റ്റിൽ നിന്ന് ധാരാളം കാര്യങ്ങൾ കണ്ടെത്താൻ കഴിയും.

എന്നാൽ പ്രശ്നം എന്താണ്?

ഇത് കോഡിന്റെ ഘടനയെ ശരിക്കും മനസ്സിലാക്കുന്നില്ല.

ഒരാളോട് "ജോൺ" എന്നൊരാളെ കണ്ടെത്താൻ പറഞ്ഞാൽ, അയാൾക്ക് "ജോൺ" എന്ന പേര് കണ്ടെത്താൻ കോൺടാക്റ്റ് ലിസ്റ്റ് ഓരോ പേജായി മറിച്ചുനോക്കേണ്ടിവരും.

എന്നാൽ നിങ്ങൾ മൊബൈൽ ഫോണിൽ "ജോൺ" എന്ന് തിരയുമ്പോൾ, ഡാറ്റാബേസ് നേരിട്ട് എടുത്ത് ഫലം കാണിക്കുന്നു.

ഇതാണ് വ്യത്യാസം.

മുമ്പത്തെ Claude Code: ഓരോ ഫയലും വായിച്ച്, ടെക്സ്റ്റ് പൊരുത്തപ്പെടുത്തൽ ഉപയോഗിച്ച് കണ്ടെത്തുന്നു ഇപ്പോഴത്തെ Claude Code: ലാംഗ്വേജ് സെർവറോട് നേരിട്ട് ചോദിച്ച് കൃത്യമായി കണ്ടെത്തുന്നു

കാര്യക്ഷമതയിൽ ഒരുപാട് വ്യത്യാസമുണ്ട്.

LSP Claude Code-ലേക്ക് എന്താണ് കൊണ്ടുവരുന്നത്?

5 പ്രധാന കഴിവുകൾ, ഓരോന്നും കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നവയാണ്:

1. goToDefinition - നിർവചനത്തിലേക്ക് പോകുക

VS Code-ൽ Ctrl+Click ചെയ്താൽ എന്ത് ചെയ്യാൻ കഴിയും? ഫംഗ്ഷൻ നിർവചിച്ചിട്ടുള്ള സ്ഥലത്തേക്ക് നേരിട്ട് പോകാം.

ഇപ്പോൾ Claude Code-നും ഇത് ചെയ്യാൻ കഴിയും.

നിങ്ങൾ ചോദിക്കുക: "processRequest ഫംഗ്ഷൻ എവിടെയാണ് നിർവചിച്ചിരിക്കുന്നത്? LSP ഉപയോഗിച്ച്"

എല്ലാ ഫയലുകളും മണ്ടത്തരം പോലെ തിരയേണ്ടതില്ല.

ഇത് ലാംഗ്വേജ് സെർവറോട് നേരിട്ട് ചോദിച്ച് ഉത്തരം നൽകുന്നു: ഫയലിന്റെ പേര്, ലൈൻ നമ്പർ, കൃത്യമായ സ്ഥാനം.

2. findReferences - എല്ലാ റഫറൻസുകളും കണ്ടെത്തുക

ഇതൊരു പ്രധാനപ്പെട്ട ഫീച്ചറാണ്.

നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ മാറ്റിയെഴുതണം, പക്ഷേ മാറ്റാൻ ധൈര്യമില്ല, കാരണം മറ്റ് സ്ഥലങ്ങളിൽ അത് തകരാറിലാകാൻ സാധ്യതയുണ്ട്.

എന്ത് ചെയ്യും?

മുമ്പ് Claude Code ഓരോ ഫയലായി വായിക്കാൻ പറയേണ്ടിവന്നു, അത് വളരെ മന്ദഗതിയിലായിരുന്നു.

ഇപ്പോൾ നേരിട്ട് ചോദിക്കുക: "displayError ഫംഗ്ഷൻ ഏതൊക്കെ സ്ഥലങ്ങളിൽ ഉപയോഗിച്ചിട്ടുണ്ട്? LSP ഉപയോഗിച്ച്"

ലാംഗ്വേജ് സെർവർ എല്ലാ റഫറൻസ് സ്ഥാനങ്ങളും നൽകുന്നു.

വേഗത്തിലും കൃത്യമായും കണ്ടെത്തുന്നു.

3. hover - ഡോക്യുമെൻ്റേഷനും ടൈപ്പ് വിവരങ്ങളും നേടുക

VS Code-ൽ മൗസ് ഹോവർ ചെയ്യുമ്പോൾ, ഫംഗ്ഷൻ സിഗ്നേച്ചർ, പാരാമീറ്റർ ടൈപ്പ്, ഡോക്യുമെൻ്റേഷൻ വിവരങ്ങൾ എന്നിവ കാണാൻ കഴിയും.

Claude Code-നും ഇപ്പോൾ ഇത് കാണാൻ കഴിയും.

അതിനോട് ചോദിക്കുക: "displayBooks ഫംഗ്ഷൻ ഏത് പാരാമീറ്ററുകളാണ് സ്വീകരിക്കുന്നത്? LSP ഉപയോഗിച്ച്"

അതിന് ഊഹിക്കേണ്ടതില്ല, ലാംഗ്വേജ് സെർവർ നൽകുന്ന സിഗ്നേച്ചർ നേരിട്ട് വായിക്കുന്നു.

പ്രത്യേകിച്ച് Python പോലുള്ള ഡൈനാമിക് ഭാഷകളിൽ, മുമ്പ് Claude കോൺടെക്സ്റ്റ് അനുസരിച്ച് ടൈപ്പ് ഊഹിക്കേണ്ടി വന്നു.ഇപ്പോൾ LSP ഉപയോഗിച്ച്, ടൈപ്പ് വിവരങ്ങൾ ഒറ്റനോട്ടത്തിൽ ലഭ്യമാണ്.\n\n### 4. documentSymbol - ഫയലിലെ എല്ലാ ചിഹ്നങ്ങളും ലിസ്റ്റ് ചെയ്യുക\n\nഒരു ഫയലിൽ ഏതൊക്കെ ക്ലാസുകൾ, ഫംഗ്ഷനുകൾ, വേരിയബിളുകൾ ഉണ്ട് എന്ന് പെട്ടെന്ന് അറിയാൻ ആഗ്രഹമുണ്ടോ?\n\nക്ലോഡിനോട് ചോദിക്കുക: \ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം Claude Code റീസ്റ്റാർട്ട് ചെയ്യുക.

claude

ഘട്ടം 5: പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക

/plugin എന്ന് ടൈപ്പ് ചെയ്ത് "Installed" ടാബിൽ നിങ്ങളുടെ പ്ലഗിൻ കാണുന്നുണ്ടോ എന്ന് പരിശോധിക്കുക. കണ്ടാൽ ശരിയായി.

ഒന്ന് പരീക്ഷിച്ചുനോക്കൂ:

LSP ഉപയോഗിച്ച് someFunction-ൻ്റെ എല്ലാ റഫറൻസുകളും കണ്ടെത്തുക Claude Code grep-ന് പകരം find_references ടൂളാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ അത് വിജയകരമായി ഇൻസ്റ്റാൾ ചെയ്തു എന്ന് മനസ്സിലാക്കാം.

എപ്പോഴാണ് LSP ഉപയോഗിക്കേണ്ടത്? എപ്പോഴാണ് ഉപയോഗിക്കേണ്ടാത്തത്?

LSP ഒരു അത്ഭുത മരുന്നല്ല.

LSP ഉപയോഗിക്കാൻ പറ്റിയ സാഹചര്യങ്ങൾ:

• വലിയ പ്രോജക്ടുകൾ (നൂറുകണക്കിന് ഫയലുകൾ)

• ഫയലുകൾക്കിടയിൽ ഫംഗ്ഷൻ കോളുകൾ കണ്ടെത്താൻ

• കൃത്യമായ ഫംഗ്ഷൻ സിഗ്നേച്ചറുകൾ ആവശ്യമുള്ളപ്പോൾ (പ്രത്യേകിച്ച് ഡൈനാമിക് ലാംഗ്വേജുകളിൽ)

• കോഡ് റീഫാക്ടർ ചെയ്യുമ്പോൾ, ബഗ്ഗുകൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ടെങ്കിൽ

LSP ഉപയോഗിക്കാൻ പറ്റാത്ത സാഹചര്യങ്ങൾ:

• ചെറിയ പ്രോജക്ടുകൾ, പെട്ടെന്നുള്ള സ്ക്രിപ്റ്റുകൾ

• ലളിതമായ ടെക്സ്റ്റ് സെർച്ചിംഗുകൾ

• ഒരു സ്ട്രിംഗ് എവിടെയാണെന്ന് കണ്ടെത്താൻ

ചുരുക്കിപ്പറഞ്ഞാൽ, grep വേഗത്തിൽ കിട്ടുന്ന കാര്യങ്ങൾക്ക് അത് ഉപയോഗിക്കുക, LSP കൃത്യമായി കിട്ടുന്ന കാര്യങ്ങൾക്ക് LSP ഉപയോഗിക്കുക.

ഉപകരണങ്ങൾ മനുഷ്യന് വേണ്ടി ഉണ്ടാക്കിയതാണ്, ഉപയോഗിക്കാൻ വേണ്ടി ഉണ്ടാക്കിയതല്ല.

കുറച്ച് കുഴപ്പങ്ങൾ, മുൻകൂട്ടി പറയാം

കുഴപ്പം 1: ലാംഗ്വേജ് സെർവർ PATH-ൽ ഉണ്ടായിരിക്കണം

Claude Code "No LSP server available" എന്ന് പറഞ്ഞാൽ, നിങ്ങളുടെ ലാംഗ്വേജ് സെർവർ ശരിയായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല അല്ലെങ്കിൽ PATH-ൽ ഇല്ല എന്നാണ് അർത്ഥം.

ടെർമിനലിൽ which pyright (അല്ലെങ്കിൽ നിങ്ങളുടെ ലാംഗ്വേജ് സെർവർ) റൺ ചെയ്ത് നോക്കുക, കണ്ടെത്താൻ കഴിയുന്നുണ്ടോ എന്ന്.

കുഴപ്പം 2: പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം റീസ്റ്റാർട്ട് ചെയ്യണം

പുതിയ പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്താലോ ലാംഗ്വേജ് സെർവർ അപ്ഡേറ്റ് ചെയ്താലോ, Claude Code റീസ്റ്റാർട്ട് ചെയ്യാൻ മറക്കരുത്.

ലാംഗ്വേജ് സെർവർ സ്റ്റാർട്ട് ചെയ്യുമ്പോൾ ലോഡ് ചെയ്യുന്നതാണ്.

കുഴപ്പം 3: ചിലപ്പോൾ "LSP ഉപയോഗിക്കുക" എന്ന് വ്യക്തമായി പറയേണ്ടി വരും

Claude Code grep ആണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, "LSP ഉപയോഗിക്കുക" എന്ന് ചേർക്കുക:

LSP ഉപയോഗിച്ച് authenticateUser-ൻ്റെ എല്ലാ റഫറൻസുകളും കണ്ടെത്തുക അപ്പോൾ അത് ലാംഗ്വേജ് സെർവർ ഉപയോഗിക്കും.

കുഴപ്പം 4: വിഷ്വൽ സൂചനകൾ ഉണ്ടാകില്ല

VS Code-ൽ ഉള്ളതുപോലെ, LSP സെർവർ പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് Claude Code പറയില്ല.

സ്റ്റാറ്റസ് ബാർ ഐക്കണോ അറിയിപ്പോ ഉണ്ടാകില്ല.

പരിശോധിക്കാനുള്ള ഒരേയൊരു വഴി: ടെസ്റ്റ് ചെയ്യുക.

അവസാനമായി രണ്ട് വാക്ക്

Claude Code LSP സപ്പോർട്ട് ചെയ്യുന്നത് ചെറിയ അപ്ഡേറ്റല്ല, വലിയ മാറ്റമാണ്.

മുമ്പ് ഇത് "ടെക്സ്റ്റ് സെർച്ച് + AI അനുമാനം" ആയിരുന്നു.

ഇപ്പോൾ ഇത് "ലാംഗ്വേജ് സെർവർ + AI മനസ്സിലാക്കൽ" ആണ്.

നിങ്ങൾ ഫോൺ ബുക്ക് മറിച്ചുനോക്കുന്നതിന് പകരം സെർച്ച് എഞ്ചിൻ ഉപയോഗിക്കുന്നത് പോലെയാണിത്.

കാര്യക്ഷമതയിലുള്ള വ്യത്യാസം വളരെ വലുതാണ്.

നിങ്ങൾ Claude Code ഉപയോഗിച്ച് ഒരു പ്രോജക്റ്റ് ചെയ്യുകയാണെങ്കിൽ, 5 മിനിറ്റ് എടുത്ത് LSP ശരിയാക്കുക.

ആ 5 മിനിറ്റ് വിലമതിക്കും.

ചെയ്യേണ്ട കാര്യങ്ങൾ:

• shell കോൺഫിഗറേഷനിൽ export ENABLE_LSP_TOOLS=1 ചേർക്കുക

• Claude Code തുറന്ന് /plugin റൺ ചെയ്ത് നിങ്ങളുടെ ലാംഗ്വേജ് പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്യുക

• അനുയോജ്യമായ ലാംഗ്വേജ് സെർവർ ബൈനറി ഫയലുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക

• Claude Code റീസ്റ്റാർട്ട് ചെയ്യുക

• "LSP ഉപയോഗിച്ച് XXX-ൻ്റെ എല്ലാ റഫറൻസുകളും കണ്ടെത്തുക" എന്ന് ടെസ്റ്റ് ചെയ്യുക

ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, നിങ്ങൾ കണ്ടെത്തും: ഇത്ര വേഗത്തിലോ Claude Code-ന് ഇത് ചെയ്യാൻ കഴിയും!