షేర్ చేసిన MCP సర్వర్లు

Claude Code యూజర్ MCP సర్వర్లను .claude.json లో ఉంచుతుంది, ఖాతా లాగిన్‌ను కలిగి ఉండే అదే ఫైల్, కాబట్టి ఆ ఫైల్‌ను ఖాతాల మధ్య షేర్ చేయలేము. ccam షేర్ చేసిన సర్వర్లను mcp.json అనే గ్రూప్ ఫైల్‌లో ఉంచి, ప్రారంభంలో గ్రూప్‌లోని ప్రతి ఖాతాకు దాన్ని అందిస్తుంది. మీ అన్ని ఖాతాల కోసం ఒక సర్వర్‌ను ఒక్కసారి జోడించడానికి ccam mcp ను, ఒక సెషన్ లోపల మీరు జోడించిన సర్వర్‌ను ఇతర ఖాతాలకు తరలించడానికి ccam mcp import ను ఉపయోగించండి.

వినియోగం

ccam mcp add fs -- npx -y @modelcontextprotocol/server-filesystem ~/code   # a local (stdio) server
ccam mcp add ctx --url https://mcp.context7.com/mcp --header 'Authorization: Bearer …'
ccam mcp add docs --url https://example.com/sse --transport sse
ccam mcp add db -e PGHOST=localhost -- pg-mcp                    # with an environment variable
ccam mcp add-json gh '{"type":"http","url":"https://api.githubcopilot.com/mcp/"}'
ccam mcp add tools -g team -- tools-mcp                           # into the group team
ccam mcp list                                                     # every group, and servers only one account has
ccam mcp remove ctx
ccam mcp import work                                              # move work's own servers into its group
ccam mcp import work gh --force                                   # replace the group's different gh

మార్పు ప్రతి ఖాతా తదుపరి ప్రారంభం నుంచి వర్తిస్తుంది; రన్ అవుతున్న సెషన్‌లు తాము ప్రారంభమైన సర్వర్లనే ఉంచుకుంటాయి:

$ ccam mcp add fs -- npx -y @modelcontextprotocol/server-filesystem ~/code
✓ fs added in group default — applies from the next launch
$ ccam mcp list
group default (work, side)
  ctx                  http https://mcp.context7.com/mcp
  fs                   stdio npx -y @modelcontextprotocol/server-filesystem /home/me/code
only in account work: pg

గ్రూప్‌లో ఇప్పటికే ఉన్న పేరును జోడిస్తే దాని నిర్వచనం భర్తీ అవుతుంది, added బదులు updated అని ప్రింట్ అవుతుంది. ఒక ఖాతా ఆ గ్రూప్‌తో MCP ను షేర్ చేస్తేనే (ccam share <name> --mcp on) సర్వర్లు దానికి అందుతాయి; ఇంకా ఏ ఖాతా MCP ను షేర్ చేయకపోతే, add ఆ విషయం చెబుతుంది.

ఆప్షన్లు

add కు -- తర్వాత ఒక కమాండ్ గానీ --url గానీ అవసరం; లేకపోతే అది a command to run (after --) or --url is required తో విఫలమవుతుంది. --header --url సర్వర్లకు, --env కమాండ్ సర్వర్లకు వర్తిస్తాయి. add-json claude mcp add-json తీసుకునే అదే JSON ను తీసుకుంటుంది, నిర్వచనం command లేదా url ఉన్న ఆబ్జెక్ట్ అయి ఉండాలి. import ఎప్పుడూ ఖాతా MCP ను షేర్ చేసే గ్రూప్‌నే ఉపయోగిస్తుంది, list ప్రతి గ్రూప్‌ను చూపిస్తుంది, కాబట్టి -g వాటిని మార్చదు.

ఇది ఎలా పనిచేస్తుంది

సంబంధిత ఫైళ్లు:

• ~/.local/share/ccam/groups/<group>/mcp.json: షేర్ చేసిన సర్వర్లు, {"mcpServers": {…}}, --mcp-config చదివే ఫార్మాట్. సర్వర్ ఎంట్రీలలో తరచుగా API కీలు ఉంటాయి కాబట్టి, ఇది fsutil.AtomicWrite తో, 0600 మోడ్‌తో రాయబడుతుంది.
• ~/.local/share/ccam/profiles/<name>/.claude.json: ఖాతా సర్వర్లు ఉన్న Claude Code సొంత ఫైల్. ccam profile.TopLevelValue స్కానర్‌తో దాని mcpServers విలువను మాత్రమే చదువుతుంది, ప్రారంభ మార్గంలో మొత్తం ఫైల్‌ను ఎప్పుడూ పార్స్ చేయదు.
• ~/.local/state/ccam/mcp/<name>/: seen ఫైల్, sync-stamp, .claude.json బ్యాకప్‌లు.

~/.config/ccam/config.toml లోని mcp_strategy తో సెట్ చేసే రెండు విధానాలు ఉన్నాయి. డిఫాల్ట్ ఫ్లాగ్ విధానం:

1. launcher.applyMCP ఖాతా MCP గ్రూప్‌ను కనుగొంటుంది. mcp.FlagArgs గ్రూప్ mcp.json ఉందో లేదో, దాన్ని పార్స్ చేయకుండా, ఒక stat తో తనిఖీ చేస్తుంది.
2. Plan.InsertArgs --mcp-config=<path> ను claude తర్వాత వెంటనే, మీ సొంత ఆర్గ్యుమెంట్‌ల ముందు పెడుతుంది, కాబట్టి మీ సొంత --mcp-config లేదా --strict-mcp-config దానిపై అదనంగా వర్తిస్తాయి.
3. చివరి ప్రారంభం తర్వాత ఖాతా .claude.json మారిందో లేదో mcp.NewLocal తనిఖీ చేసి, అప్పుడు మాత్రమే దాని సర్వర్లను పార్స్ చేస్తుంది.
4. syscall.Exec ccam ను Claude Code తో భర్తీ చేస్తుంది.

పాత్ రెండు కాకుండా ఒకే ఆర్గ్యుమెంట్‌గా, --mcp-config=<path> గా పంపబడుతుంది. Claude Code యొక్క --mcp-config అనేక విలువలను తీసుకుంటుంది, కాబట్టి claude --mcp-config a.json "prompt" ప్రాంప్ట్‌ను రెండో కాన్ఫిగ్ ఫైల్‌గా చదివి MCP config file not found తో విఫలమవుతుంది. ఒకే ఆర్గ్యుమెంట్ రూపం అక్కడే ఆగుతుంది, తర్వాత వచ్చే ప్రాంప్ట్ లేదా mcp list వంటి సబ్‌కమాండ్ పనిచేస్తుంది. Claude Code ఖాతా సొంత సర్వర్లతో పాటు --mcp-config సర్వర్లను లోడ్ చేస్తుంది; పేరు ఘర్షణ అయితే .claude.json లోని ఎంట్రీ గెలుస్తుంది. ఫ్లాగ్ విధానం ఎప్పుడూ .claude.json లో రాయదు.

సెషన్ లోపల claude mcp add తో జోడించిన సర్వర్ ఆ ఖాతా .claude.json లో మాత్రమే చేరుతుంది. ఆ సమయంలో ccam దాన్ని చూడలేదు, ఎందుకంటే Claude Code దాన్ని భర్తీ చేసింది, కాబట్టి అది తదుపరి ప్రారంభంలో తనిఖీ చేస్తుంది. seen ఫైల్‌లో .claude.json మార్పు సమయం, ఇప్పటికే నివేదించిన సర్వర్ పేర్లు ఉంటాయి. సమయం వేరుగా ఉన్నప్పుడు, ccam పేర్లను గ్రూప్‌తో పోల్చి, ఇన్‌పుట్ కోసం వేచి ఉండకుండా, ప్రతి కొత్త సర్వర్‌కు ఒకసారి సూచనను ప్రింట్ చేస్తుంది:

ccam: MCP servers only account work has: pg
      To share them with other accounts: ccam mcp import work pg

mcp_strategy = "sync" తో, సర్వర్లు claude mcp list, /mcp లో సాధారణ యూజర్ సర్వర్లుగా కనిపిస్తాయి, ccam ప్రారంభానికి ముందు వాటిని ప్రతి ఖాతా .claude.json లో రాస్తుంది:

1. mcp.Sync గ్రూప్ mcp.json మార్పు సమయాన్ని sync-stamp తో పోలుస్తుంది. అది మారకపోతే, ఖాతా .claude.json తెరవబడదు.
2. అది Claude Code సొంత లాక్‌ను తీసుకుంటుంది, అంటే ఫైల్ పక్కన mkdir తో సృష్టించే .claude.json.lock ఫోల్డర్. Claude Code లాక్ లైబ్రరీ లాగే, అది గరిష్ఠంగా 2 సెకన్లు వేచి ఉంటుంది, 10 సెకన్ల కంటే పాత లాక్‌ను పాతబడినదిగా పరిగణిస్తుంది.
3. ప్రస్తుత .claude.json ను స్టేట్ ఫోల్డర్‌లోని backups/ లో సేవ్ చేసి, కొత్తవైన 5 ను ఉంచుతుంది.
4. ప్రతి గ్రూప్ సర్వర్‌ను mcpServers లో సెట్ చేస్తుంది, తాను ముందు రాసిన కానీ ఇప్పుడు గ్రూప్‌లో లేని సర్వర్లను తీసివేస్తుంది, ఖాతా సొంత సర్వర్లను ఉంచుతుంది, ఫైల్‌ను దాని అసలు మోడ్‌తో అటామిక్‌గా రాస్తుంది.
5. కొత్త స్టాంప్‌ను, తాను నిర్వహించే పేర్లను నమోదు చేస్తుంది, Claude Code --mcp-config లేకుండా ప్రారంభమవుతుంది.

Claude Code రన్ అవుతున్నప్పుడు .claude.json ను మళ్లీ రాస్తుంది కాబట్టి, ఖాతా సెషన్ రన్ అవుతుంటే సింక్ ccam: account work is already running, skipping MCP sync తో దాటవేయబడుతుంది. సింక్ విఫలమైతే ccam: MCP sync failed (launching anyway): … అని ప్రింట్ చేసి, అయినా ప్రారంభిస్తుంది. సెషన్ లోపల జోడించిన సర్వర్ల సూచన ఫ్లాగ్ విధానానికి మాత్రమే చెందుతుంది.

ccam mcp import ఒక ఖాతా సొంత సర్వర్లను దాని గ్రూప్‌లోకి తరలిస్తుంది:

ccam mcp.LocalServers తో ఖాతా సర్వర్లను చదివి, ప్రతిదాన్ని అదే పేరు గల గ్రూప్ సర్వర్‌తో mcp.SameDef ద్వారా పోలుస్తుంది, అది కీల క్రమాన్ని, ఖాళీలను పట్టించుకోదు. గ్రూప్‌లో లేని లేదా అదే నిర్వచనంతో ఉన్న సర్వర్ కాపీ అవుతుంది. వేరుగా ఉన్నది దాటవేయబడుతుంది, ఎందుకంటే మిగతా ప్రతి ఖాతా ఉపయోగించేది గ్రూప్ నిర్వచనమే:

Skipped gh: group default already has a different gh (`ccam mcp import work gh --force` replaces it)
✓ Copied to group default: pg
✓ Removed account work's own entries (.claude.json backed up)

--force తో గ్రూప్ సర్వర్ భర్తీ అవుతుంది, మునుపటి mcp.json ముందుగా గ్రూప్ ఫోల్డర్‌లోని .ccam-backup/<time>/mcp.json లో సేవ్ అవుతుంది. ఆపై mcp.RemoveLocal అదే లాక్ కింద, స్టేట్ ఫోల్డర్‌లో బ్యాకప్ తర్వాత, కాపీ చేసిన ఎంట్రీలను ఖాతా .claude.json నుంచి తీసివేస్తుంది. పేరు ఘర్షణ అయితే ఖాతా ఎంట్రీ గ్రూప్ ఎంట్రీపై గెలుస్తుంది కాబట్టి ఇది అవసరం. --keep-local వాటిని అలాగే ఉంచుతుంది.

భద్రత, ప్రత్యేక సందర్భాలు

• సైన్-ఇన్‌లు. OAuth తో సైన్ ఇన్ అయ్యే సర్వర్లు తమ టోకెన్‌లను సర్వర్ జాబితాలో కాకుండా ప్రతి ఖాతా .credentials.json (mcpOAuth) లో ఉంచుతాయి, కాబట్టి సర్వర్‌ను షేర్ చేస్తే దాని సైన్-ఇన్ షేర్ కాదు. /mcp తో ప్రతి ఖాతాలో ఒక్కసారి సైన్ ఇన్ చేయండి, లేదా ccam migrate తో ~/.claude నుంచి సైన్-ఇన్‌లను కాపీ చేయండి. గ్రూప్‌కు ఎప్పుడూ లాగిన్ ఫైల్ అందదు.
• రన్ అవుతున్న ఖాతాలు. import గ్రూప్‌కు కాపీ చేస్తుంది కానీ రన్ అవుతున్న ఖాతా సొంత ఎంట్రీలను వదిలేసి ఆ విషయం చెబుతుంది; సెషన్ ముగిసిన తర్వాత దాన్ని మళ్లీ రన్ చేయండి. సింక్ రన్ అవుతున్న ఖాతాలను దాటవేస్తుంది.
• పాడైన ఫైళ్లు. .claude.json చెల్లుబాటయ్యే JSON కాకపోతే, సింక్ దాన్ని ముట్టుకోకుండా ఎర్రర్‌ను నివేదిస్తుంది. 2 సెకన్లలో లాక్ తీసుకోలేకపోతే, ccam could not lock … (Claude Code is writing the file) అని నివేదిస్తుంది.
• MCP ను షేర్ చేయని ఖాతాలు. import తిరస్కరించి, ముందుగా ccam share side --mcp on రన్ చేయమని చెబుతుంది.
• గ్రూప్ పేర్లు. -g గ్రూప్ పేరును మాత్రమే తీసుకుంటుంది; అది groups/ కింద ఒక ఫోల్డర్ అవుతుంది, కాబట్టి ../x వంటి పేర్లు తిరస్కరించబడతాయి.

సంబంధిత పేజీలు

• ఖాతాల మధ్య షేరింగ్
• MCP సర్వర్లు, సెట్టింగ్‌లు, చరిత్రను షేర్ చేయండి
• ఇప్పటికే ఉన్న సెటప్‌ను కాపీ చేయండి
• అన్ని కమాండ్‌లు