HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
Scale3-Labs
langtrace
TypeScript2024–2024
Scale3-Labs / langtrace

langtrace

Langtrace 🔍 is an open-source, Open Telemetry based end-to-end observability tool for LLM applications, providing real-time tracing, evaluations and metrics for popular LLMs, LLM frameworks, vectorDBs and more.. Integrate using Typescript, Python. 🚀💻📊

5Distinct people
14Mentions
0Explicit recommenders
1.2KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Langtrace 🔍 is an open-source, Open Telemetry based end-to-end observability tool for LLM applications, providing real-time tracing, evaluations and metrics for popular LLMs, LLM frameworks, vectorDBs and more.. Integrate using Typescript, Python. 🚀💻📊

GitHub

Where it is used

No documented product use has been verified yet.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 4:00:59 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by month14 dated mentions

Observed mentions: 2024-04-25 16:00:08 UTC to 2024-12-23 21:14:03 UTC.

02462024-04-01 00:00:00 UTC to 2024-05-01 00:00:00 UTC (exclusive): 7 mentions; 3 submissions, 4 commentsApr 20242024-05-01 00:00:00 UTC to 2024-06-01 00:00:00 UTC (exclusive): 3 mentions; 2 submissions, 1 comments2024-06-01 00:00:00 UTC to 2024-07-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2024-07-01 00:00:00 UTC to 2024-08-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2024-08-01 00:00:00 UTC to 2024-09-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 commentsAug 20242024-09-01 00:00:00 UTC to 2024-10-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2024-10-01 00:00:00 UTC to 2024-11-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2024-11-01 00:00:00 UTC to 2024-12-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2024-12-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 commentsDec 2024

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
Apr 20242024-04-01 00:00:00 UTC2024-05-01 00:00:00 UTC734
May 20242024-05-01 00:00:00 UTC2024-06-01 00:00:00 UTC321
Jun 20242024-06-01 00:00:00 UTC2024-07-01 00:00:00 UTC303
Jul 20242024-07-01 00:00:00 UTC2024-08-01 00:00:00 UTC000
Aug 20242024-08-01 00:00:00 UTC2024-09-01 00:00:00 UTC000
Sep 20242024-09-01 00:00:00 UTC2024-10-01 00:00:00 UTC000
Oct 20242024-10-01 00:00:00 UTC2024-11-01 00:00:00 UTC000
Nov 20242024-11-01 00:00:00 UTC2024-12-01 00:00:00 UTC000
Dec 20242024-12-01 00:00:00 UTC2025-01-01 00:00:00 UTC101

What Hacker News says

14 sources
Congrats on the launch. Cool to see a RAG specific tracing tool. Excited to try it out. Full disclosure, I am the cofounder and core-maintainer of Langtrace(https://github.com/Scale3-Labs/langtrace) which is also an open source tool for tracing and observing your LLM stack and our SDKs are OTEL based. Based on my experience, I think the biggest challenge right now specifically for RAG pipelines is the lack of flexibility in the current crop of tracing tools to not just visualize the entire retrieval flow across all the components of the stack - the framework calls, vectorDB retrievals, re-ranker i/o if any and the final LLM inference. But, also being able to do experiments by freezing a setup, iterate on it and measuring the performance and improving it to clearly know how the changes map to the performance end to end. This is what we thi
Read the rest
nk about mostly while we are building Langtrace as well.
In RAG Logger: An Open-Source Alternative to LangSmith
This still has the same issue that the docs say I need 2 more databases, not making use of my existing grafana LGTM stack https://github.com/Scale3-Labs/langtrace?tab=readme-ov-file#... Another blocker for me is that it appears to need an API key for trying it out locally or self-hosting --- I'm comparing your project to OpenLit on this front - https://docs.openlit.io/latest/installation#kubernetes - https://docs.openlit.io/latest/connections/grafanacloud
In Observability for LLM apps with structlog and DuckDB

Thoughts on DSPy

Been tinkering with DSPy and I thought I will share my thoughts. Let’s start by setting some context. Let’s say you are building a RAG(Retrieval Augmented Generation). The typical approach is to: 1. Chunk the documents 2. Insert into a vector store 3. Given a query, retrieve the context(s) by kNN search 4. Give the context to a language model for answer generation. This gives a great starting point but obviously this does not guarantee 100% accuracy from first iteration. Now, the typical approach is to iterate and make it better. Generally this involves tweaking: 1. Chunking and insertion strategy 2. Retrieval strategy 3. Prompt engineering After some trial n error, you arrive at the most optimal combination hyper parameter settings that gives you the best accuracy. After a few days, you realize the RAG’s accuracy has regressed. Now, ag
Read the rest
ain you are back to square one. This is a monolithic and unsustainable way to optimize. This is what DSPy tries to solve. DSPy is primarily two things: 1. Separate programming from prompt engineering using signatures and give greater control to program language models using traditional programming techniques. 2. Incorporate best practice prompting techniques in the framework to optimize the LMs response. With DSPy, you can implement and iterate on improving your app additional tools at your disposal. First, you can separate your prompts and write a signature instead. A signature looks like this “context, question -> answer”. This signature gets “compiled” into an actual prompt. In addition, you can also break this problem into 2 modules, 1. Retrieval module 2. Generation module Modules are classes that that take a signature with inputs and generate an output and you can start iterating on each module separately. Now, with the retrieval module, you can do a an iterative query generation & context retrieval before passing it to the generation module. This is a technique used to improve RAG performance by building up additional context by incrementally asking questions based on retrieved context and using the generate questions to retrieve additional context. With DSPy, this becomes straightforward because, DSPy exposes constructs like - Settings where you can define the number of hops - Signature like “context, question -> query” that gets compiled into a proper prompt - Optimizers to incrementally append retrieved contexts to the prompt automatically by the framework Coming to the answer generation module, it’s not atypical to define a set of rules while prompt engineering. DSPy solves this using run time assertions with backtracking where in, you can define an assertion instead of a rule and DSPy with automatically backtrack and improve the prompt if the assertion fails. DSPy will automatically back track and prefix the prompt to include additional rules to optimize the prompt further. Obviously, you can do this with prompt engineering & program composition. But, where DSPy really shines is when you are optimizing a large pipeline that is prone to brittleness with prompt engineering techniques. DSPy helps you compose the pipeline into isolated set of modules & lets you apply best practice prompting techniques without having to think much about the prompt. There are two implementations of the framework today. - Python - https://github.com/stanfordnlp/dspy - Typescript - https://github.com/dosco/llm-client/ One specific feature I would like to see is to expose the prompt templates as config and give greater control to the developers in incorporating our “versions” of templates for CoT, Fewshots etc. This will also help with the adoption of DSPy to languages other than English. Finally, I was able to understand what DSPy is adding to its prompts and what sort of optimizations it is doing by using Langtrace, an open source tracing tool i am building that can be setup with just 2 lines of code. https://github.com/Scale3-Labs/langtrace
1 points · Open discussion
LLMtools·May 3, 2024Submission

Show HN: Langtrace – OpenTelemetry-Based LLM App Observability Tool

Hey HN, We are working on Langtrace (https://github.com/Scale3-Labs/langtrace), an open source, open telemetry based SDK and monitoring/evaluations client for LLM based applications. The SDK generates OTEL standard spans and traces for popular LLMs like OpenAI, Anthropic and Cohere, popular frameworks like Langchain and LlamaIndex and vectorDBs like ChromaDB and Pinecone. The LLM monitoring/evaluations space has seen a number of products off late, both open source and closed source ones. However, a couple of things we have observed are: lack of standard spans and traces that creates vendor lock-in, different tools are optimized for solving different pain points - Evaluations, Prompt management, Datasets, etc. We believe that adopting OpenTelemetry (OTEL) standard tracing not only allows teams to use the SDK without having to switch their
Read the rest
observability client, but will also enable developers to develop tooling for any custom needs, such as capturing datasets, prompts, evaluations etc. A note on what we have built so far: [1] We have a Python and a TypeScript SDK and we have broken down the support for the LLM layer into 3 groups, LLMs, Frameworks and VectorDBs. Our SDKs are open telemetry compatible, can be installed and used independently and we also provide an option to pass custom exporters to export the traces and spans to any observability tool of your choice. [2] An observability client that is hyper optimized for solving the unique pain points and challenges that come with LLM based apps like Evaluations, prompt iteration, datasets etc. We are SOC2 compliant and the client can also be self hosted if you have strict data privacy and protection requirements. [3] Both the SDK and the client are fully open source. We are leaning on the community to try it out and provide us with feedback. A note about OpenTelemetry semantic conventions for LLMs - we would like to converge on standard names for trace attributes that follow the OTEL rules and are looking for feedback from experts here - https://github.com/Scale3-Labs/langtrace/discussions/71 We recognize that this project is early and there is a lot of room for improvement. We would love to hear your thoughts and feedback. Links: [1] https://langtrace.ai/ [2] https://github.com/Scale3-Labs/langtrace [3] https://docs.langtrace.ai/introduction [4] https://langtrace.ai/blog/why-you-need-opentelemetry-based-o...
4 points · Open discussion
+1 to this. Langtrace core maintainer here. We are building a SDK and a client for automatic instrumentation of LLM based applications using OTEL standards. The OpenLLMetry team along with the CNCF OpenTelemetry working group has been doing some great work standardizing semantic naming conventions and we are starting to adopt the same set of standards. [1] https://github.com/Scale3-Labs/langtrace [2] https://github.com/open-telemetry/semantic-conventions/blob/...
In Pydantic Logfire

Show HN: Langtrace – OpenTelemetry Based LLM App Observability

Hey HN, Ola and Karthik here. We are working on Langtrace(https://github.com/Scale3-Labs/langtrace), an open source, open telemetry based SDK and monitoring/evaluations client for LLM based applications. The SDK generates OTEL standard spans and traces for popular LLMs like OpenAI, Anthropic and Cohere, popular frameworks like Langchain and LlamaIndex and vectorDBs like ChromaDB and Pinecone. The LLM monitoring/evaluations space has seen a number of products off late, both open source and closed source ones. But, a couple of things we have observed are: lack of standard spans and traces that creates vendor lock in, different tools are optimized for solving different pain points - Evaluations, Prompt management, Datasets etc. We believe that adopting open telemetry(OTEL) standard tracing not only lets teams use our SDK without having to sw
Read the rest
itch their observability client, but will also enable developers to develop tooling for any custom needs such as capturing datasets, prompts, evaluations etc. A quick note on what we have built so far: [1] We have a Python and a TypeScript SDK and we have broken down the support for the LLM layer into 3 groups, LLMs, Frameworks and VectorDBs. Our SDKs are open telemetry compatible, can be installed and used independently and we also provide an option to pass custom exporters to export the traces and spans to any observability tool of your choice. [2] An observability client that is hyper optimized for solving the unique pain points and challenges that come with LLM based apps like Evaluations, prompt iteration, datasets etc. We are SOC2 compliant and the client can also be self hosted if you have strict data privacy and protection requirements. [3] Both the SDK and the client are fully open source. We are leaning on the community to try it out and provide feedback. A note about Open Telemetry semantic conventions for LLMs - We would like to converge on standard names for trace attributes that follow the OTEL rules and are looking for feedback from experts here - https://github.com/Scale3-Labs/langtrace/discussions/71 We recognize that this project is early and there is a lot of room for improvement. Would love to hear your thoughts and feedback. Thanks! Links: [1] https://langtrace.ai/ [2] https://github.com/Scale3-Labs/langtrace [3] https://docs.langtrace.ai/introduction
2 points · Open discussion

Show HN: Langtrace – OpenTelemetry-Based LLM App Observability

Hey HN, Ola and Karthik here. We are working on Langtrace(https://github.com/Scale3-Labs/langtrace), an open source, open telemetry based SDK and monitoring/evaluations client for LLM based applications. The SDK generates OTEL standard spans and traces for popular LLMs like OpenAI, Anthropic and Cohere, popular frameworks like Langchain and LlamaIndex and vectorDBs like ChromaDB and Pinecone. The LLM monitoring/evaluations space has seen a number of products off late, both open source and closed source ones. But, a couple of things we have observed are: lack of standard spans and traces that creates vendor lock in, different tools are optimized for solving different pain points - Evaluations, Prompt management, Datasets etc. We believe that adopting open telemetry(OTEL) standard tracing not only lets teams use our SDK without having to sw
Read the rest
itch their observability client, but will also enable developers to develop tooling for any custom needs such as capturing datasets, prompts, evaluations etc. A quick note on what we have built so far: [1] We have a Python and a TypeScript SDK and we have broken down the support for the LLM layer into 3 groups, LLMs, Frameworks and VectorDBs. Our SDKs are open telemetry compatible, can be installed and used independently and we also provide an option to pass custom exporters to export the traces and spans to any observability tool of your choice. [2] An observability client that is hyper optimized for solving the unique pain points and challenges that come with LLM based apps like Evaluations, prompt iteration, datasets etc. We are SOC2 compliant and the client can also be self hosted if you have strict data privacy and protection requirements. [3] Both the SDK and the client are fully open source. We are leaning on the community to try it out and provide feedback. A note about Open Telemetry semantic conventions for LLMs - We would like to converge on standard names for trace attributes that follow the OTEL rules and are looking for feedback from experts here - https://github.com/Scale3-Labs/langtrace/discussions/71 We recognize that this project is early and there is a lot of room for improvement. Would love to hear your thoughts and feedback. Thanks! Links: [1] https://langtrace.ai/ [2] https://github.com/Scale3-Labs/langtrace [3] https://docs.langtrace.ai/introduction [4] https://langtrace.ai/blog/why-you-need-opentelemetry-based-o...
9 points · Open discussion
Hey HN, Ola and Karthik here. We are working on Langtrace (https://github.com/Scale3-Labs/langtrace), an open source, open telemetry based SDK and monitoring/evaluations client for LLM based applications. The SDK generates OTEL standard spans and traces for popular LLMs like OpenAI, Anthropic and Cohere, popular frameworks like Langchain and LlamaIndex and vectorDBs like ChromaDB and Pinecone. The LLM monitoring/evaluations space has seen a number of products off late, both open source and closed source ones. However, a couple of things we have observed are: lack of standard spans and traces that creates vendor lock-in, different tools are optimized for solving different pain points - Evaluations, Prompt management, Datasets, etc. We believe that adopting OpenTelemetry (OTEL) standard tracing not only allows teams to use the SDK without h
Read the rest
aving to switch their observability client, but will also enable developers to develop tooling for any custom needs, such as capturing datasets, prompts, evaluations etc. A note on what we have built so far: [1] We have a Python and a TypeScript SDK and we have broken down the support for the LLM layer into 3 groups, LLMs, Frameworks and VectorDBs. Our SDKs are open telemetry compatible, can be installed and used independently and we also provide an option to pass custom exporters to export the traces and spans to any observability tool of your choice. [2] An observability client that is hyper optimized for solving the unique pain points and challenges that come with LLM based apps like Evaluations, prompt iteration, datasets etc. We are SOC2 compliant and the client can also be self hosted if you have strict data privacy and protection requirements. [3] Both the SDK and the client are fully open source. We are leaning on the community to try it out and provide us with feedback. A note about OpenTelemetry semantic conventions for LLMs - we would like to converge on standard names for trace attributes that follow the OTEL rules and are looking for feedback from experts here - https://github.com/Scale3-Labs/langtrace/discussions/71 We recognize that this project is early and there is a lot of room for improvement. We would love to hear your thoughts and feedback. Thanks! Links: [1] https://langtrace.ai/ [2] https://github.com/Scale3-Labs/langtrace [3] https://docs.langtrace.ai/introduction [4] https://langtrace.ai/blog/why-you-need-opentelemetry-based-o...
In Show HN: Langtrace – OpenTelemetry-Based Client & SDK for LLM App Observability

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.