How do you detect LangChain or LlamaIndex on a website?

Best move: read the shipped JavaScript and the telemetry it phones home, not the case-studies page.

Why it works: orchestration frameworks run on the server, so their strongest external signal is the code that reaches the browser and the tracing traffic that leaves the box. Both survive minification.

Key takeaways

• LangChain and LlamaIndex are backend orchestration frameworks, so a server-only deployment leaves no front-end signature to read.
• The JavaScript ports (LangChain.js under @langchain, LlamaIndex.TS under llamaindex) leave package namespaces and client APIs in shipped bundles.
• LangSmith tracing calls to LangChain’s own ingest endpoint are a higher-confidence tell than the framework code itself, because telemetry has to leave the server.
• LangChain and LlamaIndex separate cleanly by namespace and telemetry: @langchain / langchain with LangSmith versus llamaindex / llama-index with its own tracing.
• Bassethound reports an unconfirmed orchestration layer as a gap, not a false negative, and folds any confirmed hit into the ai_readiness score and verdict.

Why are LangChain and LlamaIndex hard to see from outside?

Both frameworks live in the application backend. LangChain wires prompts, tools, retrievers, and chains; LlamaIndex builds indexes and query engines. None of that has to reach the browser. A team can run the full pipeline in a Python service behind an API and expose one JSON endpoint, and a crawler sees a normal web app with no orchestration fingerprint at all. This is the honest ceiling on outside-in detection, and it differs from detecting a vector store or a model SDK, where a client library often loads in the page. Two things change the odds. First, the JavaScript ports. LangChain.js and LlamaIndex.TS run in Node and sometimes in the browser or in edge functions, and when they do their package code ships. Second, telemetry. If a backend is wired to LangSmith, the app (or a proxy it fronts) emits tracing traffic to LangChain’s ingest endpoint, and that traffic is observable even when the framework itself is not. Bassethound leans on both, and when neither fires it records orchestration as unknown rather than absent. A negative on a static crawl is weak evidence, and the dossier says so.

What signals surface LangChain from the front end?

Four kinds. Package namespaces in shipped bundles: @langchain/core, @langchain/community, and langchain appear in import paths and minified module registries, and they survive bundling because names are load-bearing at runtime. Source maps: when a build leaves .map files exposed, the original module tree names the framework outright. Telemetry endpoints: a call to LangChain’s LangSmith tracing ingest is a strong tell, since LangSmith is LangChain’s first-party observability product and the client usually travels with the framework. Error and log strings: characteristic LangChain messages sometimes leak through client-side error reporting. Any one of these is a lead. Two together, say a @langchain import plus a LangSmith call, are a confident match. The weakest evidence is marketing copy, which is why a homepage that says “built on LangChain” counts for little on its own. Bassethound weights runtime evidence over prose. It also renders JavaScript when the static pass looks thin, because the JS ports often initialize only after hydration, and an import invisible in raw HTML shows up once the bundle executes. What it cannot reach, it lists in the dossier’s gaps.

How do you tell LangChain apart from LlamaIndex?

Namespace and telemetry split them. LangChain ships under langchain and the @langchain scope (core, community, openai, anthropic, and so on) in JS, and under langchain in Python. LlamaIndex ships under llamaindex in JS and llama-index (with llama-index-core and a wide set of llama-index-* integration packages) in Python. The client APIs differ in vocabulary: LangChain talks in chains, runnables, and agents; LlamaIndex talks in indexes, retrievers, and query engines, and those terms surface in method names inside bundles and source maps. Observability is the other splitter. A LangSmith ingest call points at LangChain. LlamaIndex integrates with its own tracing and third-party observability, so its telemetry footprint looks different. The two are not mutually exclusive. Plenty of stacks use LlamaIndex for retrieval and LangChain for agent orchestration, and Bassethound reports both when both fire rather than forcing a single answer. When only weak evidence exists for one of them, the dossier names which framework is suspected and how strong the signal is, instead of collapsing the ambiguity into a clean but wrong verdict.

What does a detected orchestration framework tell you about AI-readiness?

A confirmed orchestration layer is one of the stronger signals that a company ships AI rather than pilots it in a slide. Wiring LangChain or LlamaIndex into production means someone built retrieval, tool-calling, or multi-step chains and put them behind real traffic. In Bassethound’s AI-readiness layer, orchestration is one of the distinct signal groups the score counts. The ai_readiness score is the number of groups that fire out of six, capped at 1.0, and the verdict reads shipping when a machine-facing endpoint is present or at least three groups fire, experimenting when at least one fires, and none otherwise. An orchestration hit rarely stands alone. It tends to travel with a model provider (Anthropic or OpenAI), a vector store, and sometimes LLM observability, and that correlation is the point of a five-layer dossier: the layers cross-check each other. A stack running LangChain plus Pinecone plus a LangSmith trace is a different prospect than a site with a chat widget and nothing behind it. The icp_signal (hot, warm, or cold) reflects that density. One framework nudges the reading; the full correlated picture sets it.

Can you confirm LangChain if it only runs server-side?

Often no, and pretending otherwise is where most detection tools overclaim. If the orchestration lives in a Python service and the site fronts it with a plain API, a crawl (even one that renders JavaScript) sees nothing framework-specific. Bassethound does not manufacture a hit from a homepage mention or a single weak string. What it does is look for adjacent machine-facing evidence that a server-side AI stack tends to expose. A LangSmith tracing call that escapes the backend or a proxy. An MCP endpoint the site publishes for agents to call. A technical llms.txt or a .well-known AI file that documents the system. Each of these is server-side AI leaving a deliberate, observable mark, and each raises confidence that real orchestration sits behind the API even when the framework name never appears. When the evidence is there, the dossier says shipping and cites what it saw. When it is not, the dossier says the orchestration layer could not be confirmed from outside and marks it a gap. That honesty is the feature. A false negative you can see beats a false positive you trust.

Bassethound perspective

You cannot reliably detect LangChain or LlamaIndex on an arbitrary site, and any vendor that reports it as a clean yes or no is selling confidence it did not earn. Server-side orchestration is invisible by design. The honest read is a probability with named evidence, not a binary. So Bassethound refuses to promote a framework from a marketing mention, a single minified string, or a guess. It confirms on runtime evidence (shipped package namespaces, source maps, first-party telemetry, a published MCP or .well-known surface) and otherwise records the layer as unconfirmed. Telemetry beats framework code as a signal. A LangSmith trace has to leave the box to reach LangChain’s servers, which makes it observable in a way server-only Python imports never are. Most tech-detection tools scan the DOM and stop there. They miss the traffic that phones home. Bassethound weighs what runs and what calls out over what a page claims. The dossier tells you what it saw, how sure it is, and where it went blind. A tool that never says “I could not see this” is not measuring your stack. It is flattering it.

Sources

• LangChain documentation: https://python.langchain.com
• LlamaIndex documentation: https://docs.llamaindex.ai
• LangSmith documentation: https://docs.smith.langchain.com
• Model Context Protocol: https://modelcontextprotocol.io
• llms.txt proposal: https://llmstxt.org