Agent skill

Codebase Management

by giancarloerra in giancarloerra/SocratiCode

Set up, index, and manage SocratiCode codebase indexing. An agent skill from giancarloerra/SocratiCode.

AGPL-3.0Auto-check passedAI & LLM Engineering

Install Codebase Management

skills CLI
$ npx skills add giancarloerra/SocratiCode --skill codebase-management -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install giancarloerra/SocratiCode codebase-management --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/giancarloerra/SocratiCode.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/codebase-management .claude/skills/codebase-management && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
codebase-management
GitHub stars
3.3k
Used in
1 other repo
Token cost
~1.8k tokens
SKILL.md length
712 words
Files
2 (incl. references)
Skills in repo
2
Repo updated
First seen
Licence
AGPL-3.0

At a glance

Set up, index, and manage SocratiCode codebase indexing. An agent skill from giancarloerra/SocratiCode.

  • Works in 4 steps: Check infrastructure: codebase_health —… → Start indexing: codebase_index — runs in… → Poll progress: codebase_status — call… → …
  • The user wants to index a project
  • SKILL.md covers First-Time Setup, Incremental Updates & File…, Managing Indexes and Managing the Code Graph, plus 3 more sections
  • Reaches xyz.cloud.qdrant.io; needs OPENAI_API_KEY and GOOGLE_API_KEY

What it does

Codebase Management is an agent skill from giancarloerra/SocratiCode. Set up, index, and manage SocratiCode codebase indexing. Use when the user wants to index a project, check infrastructure health, start/stop file watching, configure context artifacts, troubleshoot indexing issues, manage the code graph, or any SocratiCode administrative task. Activates when the user mentions indexing, setting up search, SocratiCode infrastructure, or managing the codebase index.

Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/tool-reference.md`).

It sits in AI & LLM Engineering, covering Vector databases, Embeddings and Codebase knowledge for agents. It works with Model Context Protocol, Docker, Qdrant and Google Gemini. The repository describes itself as: Enterprise-grade (40m+ LOC) codebase intelligence, zero-setup, local & private Plugin/Skill/Extension or MCP: hybrid semantic search, polyglot dependency graphs, symbol-level… The licence is AGPL-3.0.

When your agent uses it

  • The user wants to index a project
  • Check infrastructure health
  • Start/stop file watching
  • Configure context artifacts

Example prompts

  • “/codebase-management”

Requirements

  • Docker
  • A credential in OPENAI_API_KEY
  • A credential in GOOGLE_API_KEY

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Check infrastructure: codebase_health — verifies Docker, Qdrant, Ollama/embedding provider, and embedding model
  2. Start indexing: codebase_index — runs in background, returns immediately
  3. Poll progress: codebase_status — call every ~60 seconds until 100% complete
  4. Done: Graph auto-builds after indexing. In the default watcher mode, the file watcher auto-starts. Ready to search.

What it can do on your machine

Read from SKILL.md and the folder at commit 1e829bf. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • xyz.cloud.qdrant.io

    Also links to:

    • ollama.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • OPENAI_API_KEY
    • GOOGLE_API_KEY
    • QDRANT_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Codebase Management loads about 1.8k tokens when it runs, and up to ~5.3k if it reads all its reference files. Until then it costs about 105 tokens; SKILL.md has 712 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~105
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from giancarloerra/SocratiCode at commit 1e829bf, republished under its AGPL-3.0 licence (© giancarloerra). 712 words, ~1,767 tokens.

Download SKILL.mdSave it as .claude/skills/codebase-management/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
codebase-management
description
Set up, index, and manage SocratiCode codebase indexing. Use when the user wants to index a project, check infrastructure health, start/stop file watching, configure context artifacts, troubleshoot indexing issues, manage the code graph, or any SocratiCode administrative task. Activates when the user mentions indexing, setting up search, SocratiCode infrastructure, or managing the codebase index.

SocratiCode Management

Set up, index, and manage SocratiCode codebase indexing, file watching, code graphs, and context artifacts.

First-Time Setup

  1. Check infrastructure: codebase_health — verifies Docker, Qdrant, Ollama/embedding provider, and embedding model
  2. Start indexing: codebase_index — runs in background, returns immediately
  3. Poll progress: codebase_status — call every ~60 seconds until 100% complete
    • This also keeps the MCP connection alive (some hosts disconnect idle connections)
  4. Done: Graph auto-builds after indexing. In the default watcher mode, the file watcher auto-starts. Ready to search.

On first use, SocratiCode automatically pulls Docker images, starts containers, and downloads the embedding model (~5 min one-time setup).

Incremental Updates & File Watching

The file watcher keeps the index automatically updated in the default SOCRATICODE_WATCHER=auto mode.

  • codebase_watch { action: "start" } — start the watcher (runs catch-up update first)
  • codebase_watch { action: "stop" } — stop the watcher
  • codebase_watch { action: "status" } — list watched projects (including cross-process)
  • codebase_update — manual incremental update (only changed files, synchronous). Usually not needed if watcher is active.

For a deliberate code-index snapshot, configure every MCP process that uses the checkout with SOCRATICODE_WATCHER=off and SOCRATICODE_AUTO_RESUME=off. Search and graph tools keep reading the existing index and graph; run codebase_update and codebase_graph_build only when a refresh is wanted. Use watcher mode manual instead when explicit codebase_watch { action: "start" } should remain available. Never try to restart a watcher whose status says disabled.

With SOCRATICODE_WATCHER=git, active indexed checkouts refresh on checked-out ref/HEAD changes, checked every 10 seconds and on search/status/graph requests. No native file watcher starts. Pending or failed refreshes are not current results. Git triggers the update, but the working tree is indexed, including uncommitted edits. Use codebase_update for file saves that do not change ref/HEAD. Selecting Git mode does not create a first index. SOCRATICODE_AUTO_RESUME=off suppresses startup catch-up, not later Git-triggered updates. A Git diagnostic must not be bypassed by starting a watcher.

Managing Indexes

  • codebase_stop — gracefully pause in-progress indexing. Current batch finishes and checkpoints. All progress preserved. Resume with codebase_index.
  • codebase_remove — delete entire index (destructive). Safely stops watcher, cancels indexing, waits for graph builds.
  • codebase_prune — inventory stored identities; delete one by exact identity, fresh confirmation token and shared-store acknowledgement. Path absence is advisory, never a candidate set.
  • codebase_list_projects — list all indexed projects with metadata, graph info, and artifact status.

Managing the Code Graph

The dependency graph is auto-built after indexing. In watcher modes manual and off, graph queries read an existing graph but will ask for an explicit build instead of creating a missing graph as a side effect.

  • codebase_graph_build — manually rebuild (background, async). Poll with codebase_graph_status.
  • codebase_graph_remove — delete graph (auto-rebuilds on next codebase_index)
  • codebase_graph_status — check build progress or graph readiness
Show full SKILL.md (284 more words)Show less

Context Artifacts Setup

To index non-code knowledge, create .socraticodecontextartifacts.json in the project root:

json
{
  "artifacts": [
    {
      "name": "database-schema",
      "path": "./docs/schema.sql",
      "description": "PostgreSQL schema — all tables, indexes, constraints, foreign keys."
    }
  ]
}

Supported types: SQL schemas, OpenAPI/Protobuf API specs, Terraform/CloudFormation configs, Kubernetes manifests, architecture docs, environment configs — any text-based file or directory.

  • codebase_context_index — manually index/re-index all artifacts (usually auto-triggered)
  • codebase_context_remove — remove all indexed artifacts (blocked during indexing)

Troubleshooting

ProblemSolution
Docker not availableInstall Docker Desktop from https://docker.com, ensure it's running
Slow indexing on macOS/WindowsDocker can't use GPU. Install native Ollama from https://ollama.com/download for Metal/CUDA acceleration. Or use cloud embeddings.
Want cloud embeddings insteadSet EMBEDDING_PROVIDER=openai + OPENAI_API_KEY, or EMBEDDING_PROVIDER=google + GOOGLE_API_KEY
Search returns no resultsCheck codebase_status — project may not be indexed. Run codebase_index.
Stale resultsCheck codebase_status. Run codebase_update; start the watcher only when status does not say it is disabled.
Indexing was interruptedRun codebase_index again — it resumes from the last checkpoint automatically.
Another process is indexingcodebase_status detects cross-process indexing. Wait for it, or use codebase_stop.

Key Environment Variables

VariableDefaultDescription
QDRANT_MODEmanagedmanaged (Docker) or external (remote/cloud Qdrant)
QDRANT_URL—Full URL for remote Qdrant (e.g. https://xyz.cloud.qdrant.io:6333)
QDRANT_API_KEY—API key for remote Qdrant
EMBEDDING_PROVIDERollamaollama, openai, or google
OPENAI_API_KEY—Required when EMBEDDING_PROVIDER=openai
GOOGLE_API_KEY—Required when EMBEDDING_PROVIDER=google
OLLAMA_MODEautoauto (detect native, fallback Docker), docker, external
EMBEDDING_MODELnomic-embed-textModel name (provider-specific)
SEARCH_DEFAULT_LIMIT10Default result limit for codebase_search (1-50)
SEARCH_MIN_SCORE0.10Default minimum RRF score threshold (0-1)
MAX_FILE_SIZE_MB5Maximum file size for indexing in MB; must be a complete finite number
EXTRA_EXTENSIONS—Additional file extensions to index (e.g. .tpl,.blade,.hbs)
SOCRATICODE_WATCHERautoauto, manual (explicit start only), off (no watcher), or git (ref/HEAD-triggered refresh, no native watcher)
SOCRATICODE_AUTO_RESUME—all resumes all stored projects; off disables startup catch-up and interrupted-index recovery

For full parameter details on every tool, see references/tool-reference.md.

© giancarloerra, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in skills/codebase-management of giancarloerra/SocratiCode.

  • SKILL.md
  • references/tool-reference.md

Open the folder on GitHubat commit 1e829bf

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in giancarloerra/SocratiCode, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Codebase Management next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Codebase Management compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Codebase Management this skillgiancarloerra/SocratiCode3.3k1 repos~1.8kAutomated safety check: PassAGPL-3.0
RAG ArchitectJeffallan/claude-skills12k1 repos~2kAutomated safety check: PassMIT
Cognee Integrations Setuptopoteretes/cognee32k—~1kAutomated safety check: NotesApache-2.0
Microsoft Extensions AImanagedcode/dotnet-skills486—~3.4kAutomated safety check: PassMIT
Chroma Vector DatabaseOrchestra-Research/AI-Research-SKILLs13k8 repos~2.3kAutomated safety check: PassMIT
Pgvector Semantic Searchtimescale/pg-aiguide1.9k1 repos~3.8kAutomated safety check: PassApache-2.0

Similar skills

  • RAG Architect

    Jeffallan/claude-skills

    Designs retrieval-augmented generation systems: document chunking, embeddings, vector store setup, hybrid search, reranking and retrieval evaluation, with checks at each step.

    12k GitHub starsUsed in 1 repo~2k tokens
    AI & LLM EngineeringAuto-check passed
  • Cognee Integrations Setup

    topoteretes/cognee

    Switches cognee's LLM, embedding, relational, vector and graph backends through environment variables, with the extras to install and the traps to avoid.

    32k GitHub stars~1k tokensUpdated today
    AI & LLM EngineeringAuto-check: notes
  • Microsoft Extensions AI

    managedcode/dotnet-skills

    Build provider-agnostic .NET AI integrations with Microsoft.Extensions.AI, IChatClient, embeddings, middleware, structured output, vector search, and evaluation.

    486 GitHub stars~3.4k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Chroma Vector Database

    Orchestra-Research/AI-Research-SKILLs

    Shows how to store documents and embeddings in Chroma, query them by similarity with metadata filters, and persist them to disk for RAG and semantic search projects.

    13k GitHub starsUsed in 8 repos~2.3k tokens
    AI & LLM EngineeringAuto-check passed
  • Pgvector Semantic Search

    timescale/pg-aiguide

    A skill your agent uses for setting up vector similarity search with pgvector for AI/ML embeddings, RAG applications, or semantic search.

    1.9k GitHub starsUsed in 1 repo~3.8k tokens
    AI & LLM EngineeringAuto-check passed
  • RAG Implementation

    wshobson/agents

    Build retrieval-augmented generation systems: pick a vector database and embedding model, choose retrieval and reranking strategies, and start from a LangGraph pipeline.

    40k GitHub starsUsed in 9 repos~1.1k tokens
    AI & LLM EngineeringAuto-check passed

More from giancarloerra/SocratiCode

  • Codebase Exploration

    giancarloerra/SocratiCode

    Explore and understand codebases using SocratiCode semantic search, dependency graphs, and context artifacts.

    3.3k GitHub starsUsed in 1 repo~1.5k tokens
    Auto-check passed

Questions about Codebase Management

What does Codebase Management do?

Set up, index, and manage SocratiCode codebase indexing. An agent skill from giancarloerra/SocratiCode. Codebase Management is an agent skill from giancarloerra/SocratiCode. Set up, index, and manage SocratiCode codebase indexing.

When should I use Codebase Management?

Codebase Management fits situations like: the user wants to index a project; check infrastructure health; start/stop file watching; configure context artifacts.

How do I install Codebase Management in Claude Code?

Run `npx skills add giancarloerra/SocratiCode --skill codebase-management -a claude-code`. Or copy the skill folder (skills/codebase-management in giancarloerra/SocratiCode) into .claude/skills/codebase-management in your project. Claude Code loads it when a task matches its description.

How do I install Codebase Management in Codex?

Run `npx skills add giancarloerra/SocratiCode --skill codebase-management -a codex`. Or copy the skill folder (skills/codebase-management in giancarloerra/SocratiCode) into .agents/skills/codebase-management in your project. Codex loads it when a task matches its description.

Can I use Codebase Management in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add giancarloerra/SocratiCode --skill codebase-management -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/codebase-management, .gemini/skills/codebase-management, .github/skills/codebase-management and .opencode/skills/codebase-management in your project.

What does Codebase Management need to run?

Going by SKILL.md and its folder, Codebase Management needs credentials named OPENAI_API_KEY, GOOGLE_API_KEY and QDRANT_API_KEY. Our summary lists: Docker; A credential in OPENAI_API_KEY; A credential in GOOGLE_API_KEY.

Does Codebase Management access the network?

SKILL.md names 2 domains. In commands or code: xyz.cloud.qdrant.io; the agent is likely to contact it when it follows the instructions. As links in the text: ollama.com. This is read from the text; nothing was executed.

Is Codebase Management safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Codebase Management use?

Codebase Management is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Codebase Management use?

About 1.8k tokens (SKILL.md is roughly 7.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.5k tokens, read only when the agent opens those files.

What are the alternatives to Codebase Management?

Skills that share tags, products or a category with Codebase Management: RAG Architect (Jeffallan/claude-skills, 12k stars), Cognee Integrations Setup (topoteretes/cognee, 32k stars), Microsoft Extensions AI (managedcode/dotnet-skills, 486 stars) and Chroma Vector Database (Orchestra-Research/AI-Research-SKILLs, 13k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Codebase Management?

giancarloerra (a GitHub user) maintains it in giancarloerra/SocratiCode, which has 3,335 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 2, 2026.

Source: giancarloerra/SocratiCode on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.