AI agent కోసం Langfuse ను self-host చేయడం ఎలా
మీ VPSలో Langfuse నడపడానికి కనీస వనరులు, pinned image tags, TLS, డిస్క్ నిండకముందే ClickHouse retention, నిజంగా పనిచేసే backups తెలుసుకోండి.
AI agent ను అసలు ఎందుకు trace చేయాలి
మీ agent ఒక run లో నిజంగా ఏమి చేసిందో చూడటానికి Langfuse ను self-host చేయండి. Langfuse అనేది open source LLM (large language model) observability tool. ఇది ప్రతి prompt, ప్రతి model response, ప్రతి tool call, ప్రతి token ను నమోదు చేసి, వాటన్నింటినీ మీరు తెరిచి చదవగల ఒకే trace కింద సమూహపరుస్తుంది. దీన్ని మీ స్వంత VPSపై నడిపితే, ఆ prompts మీ నియంత్రణలోని server ను ఎప్పటికీ విడిచిపోవు.
దీన్ని చేయాల్సిన కారణం స్పష్టంగా ఉంది. మీరు చూడలేని cost సమస్యను లేదా quality సమస్యను పరిష్కరించలేరు. Provider invoice ప్రకారం మంగళవారం ఖర్చు సోమవారం ఖర్చుకంటే నాలుగు రెట్లు అయింది. Trace మాత్రం దానికి కారణమైన agent run ఏదో, ఏ prompt 40,000 tokens కు పెరిగిందో, చివరకు విఫలమయ్యే ముందు ఏ retry loop తొమ్మిది సార్లు నడిచిందో చూపిస్తుంది. Invoice సంఖ్యను ఇస్తుంది. Trace ఆ సంఖ్యను ఉత్పత్తి చేసిన code ను చూపిస్తుంది.
ఈ guide అంతటా మూడు పదాలు ఉపయోగిస్తారు. Trace అనేది మీ agent యొక్క ప్రారంభం నుంచి ముగింపు వరకు జరిగిన ఒక run. Observation అనేది ఆ run లోని ఒక దశ: సాధారణ code కోసం ఒక span, model కు చేసిన call కోసం ఒక generation. Score అనేది trace కు జతచేయబడిన సంఖ్య; ఇది మానవ సమీక్ష లేదా automated evaluator నుంచి రావచ్చు. Langfuse distributed tracing కోసం vendor neutral standard అయిన OpenTelemetry (OTel) ను ఉపయోగిస్తుంది. అందువల్ల మీ వద్ద ఇప్పటికే ఉన్న instrumentation ను దాని వైపు పంపవచ్చు.
Langfuse self-hosting వాస్తవానికి ఎలా పనిచేస్తుంది
Langfuse v4 అనేది ఒకే కంటైనర్ కాదు. ఇది రెండు అప్లికేషన్ కంటైనర్లు మరియు నాలుగు స్టోరేజ్ సర్వీసుల కలయిక. ఒకే VPSలో ఈ ఆరు సర్వీసులు మీ సర్వర్పైనే నడుస్తాయి.
langfuse-webవెబ్ ఇంటర్ఫేస్ మరియు ఇన్జెషన్ APIని అందిస్తుంది.langfuse-workerబ్యాక్గ్రౌండ్లో క్యూ (queue)ను క్లియర్ చేస్తుంది. ఇది ఇన్జెషన్ బ్యాచ్లను పార్స్ చేస్తుంది, ఖర్చును లెక్కిస్తుంది మరియు ప్రతిరోజూ రాత్రి జరిగే రిటెన్షన్ జాబ్ను నిర్వహిస్తుంది.- Postgres వినియోగదారులు, సంస్థలు, ప్రాజెక్ట్లు, API కీలు మరియు ప్రాంప్ట్ల వంటి లావాదేవీల డేటాను నిల్వ చేస్తుంది.
- ClickHouse ట్రేస్ డేటాను, అంటే అబ్జర్వేషన్లు మరియు స్కోర్లను నిల్వ చేస్తుంది. ఇది అనలిటికల్ క్వెరీల కోసం రూపొందించబడిన కాలమ్ స్టోర్, అందుకే వంద మిలియన్ల వరుసలు ఉన్నా డాష్బోర్డ్ వేగంగా స్పందిస్తుంది.
- Redis అనేది వెబ్ మరియు వర్కర్ మధ్య ఉండే క్యూ మరియు క్యాచీగా పనిచేస్తుంది.
- MinIO మీ సర్వర్పై S3 అనుకూల ఆబ్జెక్ట్ స్టోరేజ్ను అందిస్తుంది. ఇది వచ్చే ప్రతి రా (raw) ఈవెంట్ను మరియు మీరు జతచేసే మీడియాను నిల్వ చేస్తుంది.
Langfuse ప్రతి కాంపోనెంట్ కోసం కనీస వనరులను పేర్కొంటుంది. ఈ చార్ట్ పని చేసే మూడు ప్రధాన భాగాలను చూపుతుంది.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "ClickHouse",
"cpu_cores": 2,
"memory_gib": 8
},
{
"label": "Langfuse web",
"cpu_cores": 2,
"memory_gib": 4
},
{
"label": "Langfuse worker",
"cpu_cores": 2,
"memory_gib": 4
}
]ClickHouse ఒక్కటే 8 GiB మెమరీని అడుగుతుంది. వెబ్ కంటైనర్ మరియు వర్కర్ ఒక్కొక్కటి 4 GiB మెమరీని అడుగుతాయి. చార్ట్లోని 3 కాంపోనెంట్లకు ఇవి కనీస అవసరాలు. అదే పేజీలో Postgres కోసం 4 GiB, Redis లేదా Valkey కోసం 1.5 GiB మరియు MinIO కోసం 4 GiB అని పేర్కొన్నారు, కాబట్టి ఈ ఆరు సర్వీసులకు కలిపి కనీసం 25.5 GiB అవసరం. ప్రాజెక్ట్ యొక్క Docker Compose గైడ్ ఒకే మెషీన్ కోసం కనీసం 4 కోర్లు, 16 GiB మెమరీ మరియు సుమారు 100 GiB స్టోరేజ్ను సిఫార్సు చేస్తుంది. ఇది అన్ని కాంపోనెంట్ల కనీస అవసరాల మొత్తం కంటే తక్కువ, కాబట్టి 16 GiBని షేర్డ్ Compose బాక్స్కు అవసరమైన కనీస పరిమితిగా భావించండి, అదనపు సామర్థ్యం (headroom)గా కాదు.
2 GiB ప్లాన్పై దీన్ని ప్రయత్నించవద్దు. ClickHouse ప్రారంభమై, కొంతకాలం రైట్లను స్వీకరించి, ఆపై బ్యాక్గ్రౌండ్ మెర్జ్ సమయంలో ఆగిపోతుంది, ఎందుకంటే మెర్జ్ ప్రక్రియ టేబుల్లోని పెద్ద భాగాలను మెమరీలోకి లోడ్ చేస్తుంది. అప్పుడు docker compose ps కంటైనర్ స్థితిని restartingగా చూపిస్తుంది, dmesgలో Out of memory: Killed process 1234 (clickhouse-serv) వంటి లైన్ కనిపిస్తుంది మరియు ప్రతి Langfuse డాష్బోర్డ్ 500 ఎర్రర్ను ఇస్తుంది. తక్కువ ఒత్తిడి ఉన్నప్పుడు ClickHouse క్వెరీని తిరస్కరించి DB::Exception: Memory limit (total) exceeded అని లాగ్ చేస్తుంది. ప్లాన్ చేసుకోవడానికి 16 GiB అనేది సరైన సంఖ్య. ఒకవేళ అదే VPSలో ఇతర సేవలను కూడా నడపాలనుకుంటే, వాటి కోసం విడిగా వనరులను కేటాయించండి, ఎందుకంటే self-hosted AFFiNE workspace వంటి తేలికపాటి స్టాక్లకు కూడా కొన్ని గిగాబైట్ల మెమరీ అవసరం మరియు ClickHouse తన మెమరీని తిరిగి ఇవ్వదు.
Docker Compose తో Langfuse ను డిప్లాయ్ చేయడం
Repository ని క్లోన్ చేయండి. Stack, వైరింగ్ మరియు డిఫాల్ట్ ఎన్విరాన్మెంట్ అన్నీ దాని docker-compose.yml లో ఉంటాయి.
git clone https://github.com/langfuse/langfuse.git
cd langfuseమీరు మార్చాల్సిన ప్రతి విలువ ఆ ఫైల్లో # CHANGEME తో గుర్తించబడింది. ముందుగా మూడు అప్లికేషన్ సీక్రెట్లను జనరేట్ చేయండి.
openssl rand -base64 32 # NEXTAUTH_SECRET
openssl rand -base64 32 # SALT
openssl rand -hex 32 # ENCRYPTION_KEYENCRYPTION_KEY అనేది 64 హెక్సాడెసిమల్ అక్షరాలుగా వ్రాయబడిన 256 బిట్లుగా ఉండాలి, దీనిని openssl rand -hex 32 ప్రింట్ చేస్తుంది. ఇది మీరు ఇన్స్టాన్స్లో స్టోర్ చేసే LLM ప్రొవైడర్ కీలతో సహా, నిల్వ ఉన్న సున్నితమైన విలువలను ఎన్క్రిప్ట్ చేస్తుంది. డేటా ఉన్న తర్వాత దీనిని మార్చితే ఆ రోస్ (rows) డీక్రిప్ట్ చేయలేము, కాబట్టి మొదటి బూట్ నుండే దీనిని శాశ్వతమైనదిగా పరిగణించండి. SALT మీ Langfuse API కీలను హ్యాష్ చేయడానికి ఉపయోగించబడుతుంది, కాబట్టి దీనిని మార్చడం వల్ల మీ ఏజెంట్లు ఇప్పటికే ఉపయోగిస్తున్న ప్రతి కీ చెల్లదు.
ఆ తర్వాత POSTGRES_PASSWORD, CLICKHOUSE_PASSWORD, REDIS_AUTH మరియు MINIO_ROOT_PASSWORD లను సెట్ చేయండి. MinIO పాస్వర్డ్ నాలుగు చోట్ల కనిపిస్తుంది: ఒకసారి MINIO_ROOT_PASSWORD గా, ఆపై LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY, LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY మరియు LANGFUSE_S3_BATCH_EXPORT_SECRET_ACCESS_KEY గా. ఏదైనా ఒకటి మిస్ అయితే MinIO ఆ క్లయింట్ను SignatureDoesNotMatch తో తిరస్కరిస్తుంది, ఇది వెబ్ ఇంటర్ఫేస్ ఆరోగ్యంగా ఉన్నట్లు కనిపిస్తున్నప్పటికీ వర్కర్ లాగ్లో కనిపిస్తుంది. ఈ విలువలను ట్రాక్ చేయబడిన compose ఫైల్లో కాకుండా env ఫైల్లో ఉంచడం అనేది Docker Compose env ఫైల్స్ మరియు సీక్రెట్స్ లో వివరించిన పద్ధతి.
ప్రారంభించే ముందు ఇమేజ్ ట్యాగ్లను పిన్ చేయండి
షిప్ చేయబడిన ఫైల్ docker.langfuse.com/langfuse/langfuse:4 మరియు docker.langfuse.com/langfuse/langfuse-worker:4 లను ఉపయోగిస్తుంది. ఆ ట్యాగ్లు మారుతుంటాయి. Langfuse తన Postgres మరియు ClickHouse మైగ్రేషన్లను ప్రారంభంలోనే ఆటోమేటిక్గా రన్ చేస్తుంది, కాబట్టి నెలల తర్వాత చేసే సాధారణ docker compose pull అనేది మీరు ఆ రోజు ఉదయం బ్యాకప్ తీసుకోని డేటాబేస్పై అకస్మాత్తుగా స్కీమా మైగ్రేషన్గా మారుతుంది. రెండింటినీ docker-compose.override.yml లో ఒకే రిలీజ్కు పిన్ చేయండి, దీనిని Compose షిప్ చేయబడిన ఫైల్పై మెర్జ్ చేస్తుంది, తద్వారా తర్వాత చేసే git pull మీ ఎడిట్లను ఎప్పటికీ మార్చదు. అవే ఇమేజ్లు Docker Hub లో ప్రచురించబడతాయి, అక్కడి నుండే కింద ఉన్న ఓవర్రైడ్ వాటిని తీసుకుంటుంది.
services:
langfuse-web:
image: docker.io/langfuse/langfuse:4.72.0
langfuse-worker:
image: docker.io/langfuse/langfuse-worker:4.72.0ఆగస్టు 2026 నాటికి వెర్షన్ 4.3.1 అనేది ప్రస్తుత 4.3 రిలీజ్. అప్పటి నుండి రిలీజ్లు వేగంగా వచ్చాయి, అక్టోబర్ 11, 2026 నాటికి GitHub లో v4.56.0 తాజా వెర్షన్. పైన ఉన్న ఓవర్రైడ్ v4.72.0 ని ఉపయోగిస్తుంది, ఇది అక్టోబర్ 31, 2026 నాటికి GitHub లో తాజా వెర్షన్. ప్రాజెక్ట్ యొక్క GitHub రిలీజెస్ పేజీని తనిఖీ చేయండి, మీరు డిప్లాయ్ చేసే రోజున ఏది కరెంట్గా ఉంటే దానిని పిన్ చేయండి, ఆపై ఆ నంబర్ను ఉద్దేశపూర్వకంగా మార్చండి. షిప్ చేయబడిన ఫైల్లోని కొన్ని స్టోరేజ్ ఇమేజ్లు కూడా అదే చికిత్సకు అర్హమైనవి, ఎందుకంటే వాటి ట్యాగ్లు కూడా మారుతుంటాయి. postgres:17 (POSTGRES_VERSION వేరియబుల్ యొక్క డిఫాల్ట్) మరియు redis:7 ఒక మేజర్ వెర్షన్ను అనుసరిస్తాయి. షిప్ చేయబడిన ఫైల్ ఇప్పుడు docker.io/clickhouse/clickhouse-server కోసం ఖచ్చితమైన వెర్షన్ ట్యాగ్ను ఉపయోగిస్తుంది, ఇది ఖచ్చితమైన ClickHouse వెర్షన్ను పిన్ చేస్తుంది. ఆ నియమం Langfuse కి మాత్రమే పరిమితం కాదు: ఒక self-hosted openGym వర్కవుట్ ట్రాకర్ ఈ స్టాక్లో కొంత భాగాన్ని మాత్రమే రన్ చేస్తుంది మరియు ఇప్పటికీ ఒక పేరున్న git ట్యాగ్ను కోరుకుంటుంది, ఎందుకంటే ప్రారంభంలోనే తన సొంత డేటాబేస్ను మైగ్రేట్ చేసే ఏదైనా సాఫ్ట్వేర్ సాధారణ పుల్ను స్కీమా మార్పుగా మార్చగలదు.
దీనిని ప్రారంభించండి.
docker compose up -d
docker compose ps
docker compose logs -f langfuse-workerమొదటి బూట్ మైగ్రేషన్లను రన్ చేస్తుంది, కాబట్టి ఏదీ స్పందించకముందే రెండు లేదా మూడు నిమిషాలు వేచి ఉండండి. వెబ్ కంటైనర్ ప్రారంభమైన తర్వాత Ready లాగ్ అవుతుంది. docker compose ps ఆరు సర్వీసులను running స్థితిలో చూపాలి. ఒక కంటైనర్ లూప్లో రీస్టార్ట్ అవుతుంటే, దాని లాగ్లో కారణం ఉంటుంది. వెబ్ కంటైనర్ ప్రారంభమైనప్పుడు ClickHouse మైగ్రేషన్లు వర్తింపజేయబడతాయి, కాబట్టి తప్పు CLICKHOUSE_MIGRATION_URL అనేది మీరు చూస్తున్న వర్కర్ లాగ్లో కాకుండా docker compose logs langfuse-web లో కనిపిస్తుంది. ఆ వేరియబుల్ HTTP పోర్ట్ 8123 కాకుండా, పోర్ట్ 9000 లో ClickHouse నేటివ్ ప్రోటోకాల్ను ఉపయోగిస్తుంది, దానిని 8123 కి పాయింట్ చేయడం వల్ల వెబ్ కంటైనర్ స్టార్టప్ మైగ్రేషన్లు విఫలమవుతాయి. వర్కర్ నెమ్మదిగా ఉండే బ్యాక్గ్రౌండ్ మైగ్రేషన్లను రన్ చేస్తుంది, కాబట్టి వాటి రిపోర్ట్ అక్కడ కనిపిస్తుంది.
సర్వర్ నుండే హెల్త్ చెక్ చేయండి.
curl -s "http://localhost:3000/api/public/health?failIfDatabaseUnavailable=true"
curl -s -o /dev/null -w '%{http_code}\n' http://localhost:3000/api/public/readyసాధారణ /api/public/health కాల్ API ప్రాసెస్ సజీవంగా ఉందని మాత్రమే నిరూపిస్తుంది, ఎందుకంటే డిఫాల్ట్గా ఇది డేటాబేస్ను తనిఖీ చేయదు. failIfDatabaseUnavailable=true ఫారమ్ మానిటర్ను పాయింట్ చేయడానికి సరైనది, మరియు డేటాబేస్ అందుబాటులో లేనప్పుడు ఇది 503 ని రిటర్న్ చేస్తుంది. వెబ్ కంటైనర్ ట్రాఫిక్ను స్వీకరించడానికి సిద్ధంగా ఉన్నప్పుడు /api/public/ready 200 ని రిటర్న్ చేస్తుంది, మరియు షట్డౌన్ చేయమని చెప్పిన తర్వాత 500 ని రిటర్న్ చేస్తుంది. రెండూ సాధారణ HTTP చెక్లే, కాబట్టి ఒక Uptime Kuma స్టేటస్ పేజీ వాటిని పర్యవేక్షించి, మీ ఏజెంట్ల కంటే ముందే స్టాక్ డౌన్ అయిందని మీకు తెలియజేయగలదు.
TLS ను ముందు ఉంచి అదనపు పోర్టులను మూసివేయడం
షిప్ చేసిన compose ఫైల్ వెబ్ కంటైనర్ కోసం 3000:3000 ను మరియు MinIO కోసం 9090:9000 ను పబ్లిష్ చేస్తుంది. ఇవి రెండూ అన్ని ఇంటర్ఫేస్లపై బైండ్ అవుతాయి. పబ్లిక్ IP ఉన్నప్పుడు, పోర్ట్ 3000 ను స్కాన్ చేసే ఎవరైనా మీ సైన్-అప్ పేజీని చేరుకోగలరు, అలాగే 9090 ను స్కాన్ చేసే ఎవరైనా మీ raw ప్రాంప్ట్లను కలిగి ఉన్న బకెట్తో కనెక్ట్ అవ్వగలరు.
కేవలం ఫైర్వాల్ రూల్ వాటిని మూసివేయదు. Docker తన సొంత DNAT రూల్స్ను nat టేబుల్లో రాస్తుంది. ufw ఫిల్టర్ రూల్స్ ప్యాకెట్ను చూడకముందే ఇవి అమలు చేయబడతాయి, కాబట్టి ufw deny 3000 పబ్లిష్ చేసిన పోర్ట్ను అలాగే తెరిచి ఉంచుతుంది. దీనిపై ప్రత్యేక గైడ్ ఉంది: Docker పబ్లిష్ చేసిన పోర్టులు ufw ను ఎందుకు దాటవేస్తాయి. మీ override ఫైల్లో loopback పై బైండ్ చేయండి. పబ్లిష్ చేసిన పోర్టులను భర్తీ చేయడానికి Docker Compose 2.24.4 లేదా అంతకంటే కొత్త వెర్షన్లో !override ఉపయోగించండి; సాధారణ లిస్ట్ అసలు బైండింగ్లతో కలిసిపోతుంది.
services:
langfuse-web:
ports: !override
- "127.0.0.1:3000:3000"
environment:
NEXTAUTH_URL: https://langfuse.example.com
minio:
ports: !override
- "127.0.0.1:9090:9000"
- "127.0.0.1:9091:9001"NEXTAUTH_URL అనేది స్కీమ్తో సహా ఖచ్చితమైన పబ్లిక్ అడ్రస్ అయి ఉండాలి, ఎందుకంటే లాగిన్ ఫ్లో ఆ విలువ నుండే callback URL ను నిర్మిస్తుంది. HTTPS ప్రాక్సీ వెనుక దీన్ని http://localhost:3000 గా వదిలేస్తే, సైన్-ఇన్ రౌండ్ ట్రిప్ బ్రౌజర్ను అది చేరుకోలేని చోటికి పంపుతుంది.
ఇప్పుడు రివర్స్ ప్రాక్సీని 127.0.0.1:3000 కి పాయింట్ చేసి, సర్టిఫికేట్ను దాని వద్ద ఉంచండి. అదే Compose ప్రాజెక్ట్లో Traefik కోసం, ఒకే Traefik రివర్స్ ప్రాక్సీ వెనుక అనేక యాప్లను రన్ చేయడం లో వివరించిన లేబుల్స్ ఉపయోగించి Compose నెట్వర్క్ ద్వారా langfuse-web:3000 కి రూట్ చేయండి. బాక్స్లో Langfuse మాత్రమే ఉంటే Caddy రెండు లైన్లలో ఇదే పనిని చేస్తుంది. curl -sI https://langfuse.example.com/api/public/ready తో ధృవీకరించండి, ఆపై curl http://YOUR_IP:3000 కనెక్ట్ అవ్వలేదని రెండవ మెషీన్ నుండి నిర్ధారించుకోండి.
MinIO విషయంలో ఒక హెచ్చరిక. Langfuse ఆ S3 ఎండ్పాయింట్ను సూచించే presigned URLలను మీడియాను అప్లోడ్ చేసే SDKలకు మరియు దాన్ని లోడ్ చేసే మీ బ్రౌజర్కు అందిస్తుంది. కాబట్టి మీరు ఇమేజ్లు లేదా ఆడియో ఉన్న మల్టీ-మోడల్ ట్రేస్లను ఉపయోగిస్తుంటే, loopback-మాత్రమే ఉన్న MinIO వల్ల ఆ అటాచ్మెంట్లు ఇతర మెషీన్ల నుండి అప్లోడ్ అవ్వవు లేదా మీ బ్రౌజర్లో లోడ్ అవ్వవు. ప్రాక్సీ చేసే ముందు blob స్టోరేజ్ కాన్ఫిగరేషన్ పేజీని చదవండి, ఎందుకంటే presigned URLలో వ్రాయబడిన ఎండ్పాయింట్, LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT, మీరు పబ్లిష్ చేసే దానికి సరిపోలాలి. ప్లెయిన్ టెక్స్ట్ ట్రేస్లపై దీని ప్రభావం ఉండదు.
మొదటిసారి సందర్శించినప్పుడు మీ ఖాతాను సృష్టించండి, ఆపై ఇన్స్టన్స్ను మీ ఆధీనంలో ఉంచుకోండి. మీ ఖాతా సృష్టించబడిన తర్వాత AUTH_DISABLE_SIGNUP=true సెట్ చేయండి, తద్వారా పేజీని చేరుకునే అపరిచితులు ఎవరూ రిజిస్టర్ చేసుకోలేరు. Langfuse లో LANGFUSE_ALLOWED_ORGANIZATION_CREATORS కూడా ఉంది, ఇది సంస్థలను ఎవరు సృష్టించవచ్చో పరిమితం చేస్తుంది, కానీ ఇది Enterprise Edition ఫీచర్ మరియు లైసెన్స్ కీ ఉంటేనే పనిచేస్తుంది. మీరు ఇప్పటికే Authentik ను మీ సొంత ఐడెంటిటీ ప్రొవైడర్గా రన్ చేస్తుంటే, Langfuse ప్రామాణిక OIDC కనెక్షన్ను తీసుకుంటుంది, కాబట్టి ఖాతాలు ఈ బాక్స్కు మాత్రమే తెలిసిన పాస్వర్డ్ లిస్ట్లో కాకుండా, మీ ఇతర యాప్లతో పాటు నిర్వహించబడతాయి.
మీ మొదటి trace ను పంపండి
వెబ్ ఇంటర్ఫేస్లో ఒక ప్రాజెక్ట్ను సృష్టించి, ప్రాజెక్ట్ సెట్టింగ్ల నుండి దాని public మరియు secret keys ను కాపీ చేయండి. Python SDK మూడు environment variables ను చదువుతుంది.
export LANGFUSE_PUBLIC_KEY="pk-lf-..."
export LANGFUSE_SECRET_KEY="sk-lf-..."
export LANGFUSE_BASE_URL="https://langfuse.example.com"LANGFUSE_BASE_URL అనేది SDK v4 లోని variable పేరు, ఇది 2026 మార్చిలో విడుదల చేయబడింది. పాత కోడ్ మరియు పాత గైడ్లు LANGFUSE_HOST ను ఉపయోగిస్తాయి. మీ traces మీ సర్వర్కు బదులుగా Langfuse Cloud లో చేరుతుంటే, base URL సెట్ చేయకపోవడమే దానికి కారణం, ఎందుకంటే డిఫాల్ట్గా ఇది hosted instance కి పాయింట్ చేస్తుంది.
ప్రస్తుత Python SDK v5 కి Python 3.11 లేదా అంతకంటే కొత్త వెర్షన్ మరియు self-hosted Langfuse v4.59.0 లేదా అంతకంటే కొత్త వెర్షన్ అవసరం, పైన పేర్కొన్న pinned సర్వర్ వీటిని కలిగి ఉంది.
pip install langfuse opentelemetry-instrumentation-anthropic anthropicimport os
from anthropic import Anthropic
from langfuse import get_client, observe
from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
AnthropicInstrumentor().instrument()
langfuse = get_client()
client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
@observe(as_type="tool")
def lookup_order(order_id: str) -> str:
return f"order {order_id}: shipped"
@observe()
def handle_request(question: str) -> str:
context = lookup_order("A-1042")
message = client.messages.create(
model="claude-haiku-4-5",
max_tokens=512,
messages=[{"role": "user", "content": f"{context}\n\n{question}"}],
)
return message.content[0].text
if __name__ == "__main__":
assert langfuse.auth_check()
print(handle_request("Where is my order?"))
langfuse.flush()@observe డెకరేటర్ ఫంక్షన్ చుట్టూ ఒక observation ను తెరుస్తుంది, దాని arguments మరియు return value ను క్యాప్చర్ చేస్తుంది, మరియు ఇప్పటికే యాక్టివ్గా ఉన్న ఏ observation కిందనైనా దీన్ని నెస్టెడ్ చేస్తుంది. AnthropicInstrumentor అనేది Anthropic క్లయింట్ కోసం OpenTelemetry ఇన్స్ట్రుమెంటేషన్, ఇది ప్రతి messages.create కాల్ను మోడల్ పేరు, టోకెన్ వినియోగం మరియు లాటెన్సీని కలిగి ఉన్న generation గా మారుస్తుంది, కాల్ సైట్లో ఎటువంటి మార్పు లేకుండానే ఇది జరుగుతుంది.
రెండు కాల్లు మీ కోసం తనిఖీని పూర్తి చేస్తాయి. langfuse.auth_check() తప్పు కీలు లేదా తప్పు base URL ఉన్నప్పుడు False ను రిటర్న్ చేస్తుంది, డాష్బోర్డ్ ఎందుకు ఖాళీగా ఉందో అని ఆలోచించడం కంటే ఇది వేగవంతమైన పద్ధతి. langfuse.flush() క్యూలో ఉన్న spans పంపబడే వరకు వేచి ఉంటుంది, తక్కువ సమయం నడిచే ప్రాసెస్లకు ఇది అవసరం, ఎందుకంటే SDK బ్యాక్గ్రౌండ్లో బ్యాచ్లను సిద్ధం చేస్తుంది మరియు వెంటనే ఎగ్జిట్ అయ్యే స్క్రిప్ట్ పంపబడని బ్యాచ్లను కూడా తనతో పాటు తీసుకెళ్లిపోతుంది. ఒక స్క్రిప్ట్ కాకుండా మొత్తం టీమ్ traces పంపుతుంటే, ప్రతి ఒక్కరి షెల్లో కాకుండా, అందరి ఏజెంట్లు వెళ్లే గేట్వేలో ఆ మూడు variables ను ఒకసారి సెట్ చేయండి, a self-hosted OneCLI harness ద్వారా ప్రతి సహోద్యోగి రన్లను ఎలా ఇన్స్ట్రుమెంట్ చేయాలో మరియు కీలను ఒకే చోట ఎలా ఉంచాలో ఇది చూపిస్తుంది.
ClickHouse ఎందుకు నిరంతరం పెరుగుతూ ఉంటుంది?
చాలామంది self-host చేసుకునే డేటాలో traces అత్యంత వేగంగా పెరిగేవి. ప్రతి agent రన్ ఒక అడుగుకు ఒక row ను రాస్తుంది, మరియు inputs, outputs పూర్తిగా నిల్వ చేయబడతాయి. కాబట్టి, ఎక్కువ సంభాషణలు జరిపే agent, అది పర్యవేక్షిస్తున్న అప్లికేషన్ కంటే రోజుకు చాలా ఎక్కువ bytes ను ఉత్పత్తి చేస్తుంది. దీనిని అలాగే వదిలేస్తే, ClickHouse డిస్క్ నిండిపోతుంది. డిస్క్ పూర్తిగా నిండినప్పుడు, ingestion వేగం తగ్గడం కాకుండా, పూర్తిగా ఆగిపోతుంది.
ఇక్కడ రెండు వేర్వేరు అంశాలు పెరుగుతున్నాయి, వాటికి రెండు వేర్వేరు పరిష్కారాలు అవసరం.
మొదటిది మీ స్వంత trace డేటా, దీనికి retention సెట్టింగ్ పరిష్కారం. Self-hosted instance లో, data retention అనేది Enterprise Edition ఫీచర్ మరియు దీనికి license key అవసరం. అది లేకపోతే, Langfuse traces, observations, scores మరియు media ను నిరవధికంగా ఉంచుతుంది. కాబట్టి, దానికి తగినట్లుగా డిస్క్ పరిమాణాన్ని నిర్ణయించుకోండి మరియు ఈ విభాగం చివరలో ఉన్న డిస్క్ అలర్ట్పై ఆధారపడండి. License ఉంటే, ప్రాజెక్ట్ యజమానులు మరియు అడ్మిన్లు ప్రాజెక్ట్ సెట్టింగ్స్లోకి వెళ్లి డేటా retention కాలాన్ని రోజుల్లో సెట్ చేయవచ్చు. Langfuse కనీసం 3 రోజుల కాలాన్ని అనుమతిస్తుంది. ప్రతి రాత్రి జరిగే ఒక job, ఆ కాలపరిమితి కంటే పాతవైన traces, observations, scores మరియు media assets ను గుర్తించి, వాటిని ClickHouse మరియు blob storage నుండి తొలగిస్తుంది (saved dataset items తో ముడిపడి ఉన్న media మినహా). ఈ job కు bucket పై DeleteObject అనుమతి అవసరం, ఇది డిఫాల్ట్ compose ఫైల్లోని MinIO root credentials కు ఇప్పటికే ఉంటుంది. తొలగింపు శాశ్వతమైనది, కాబట్టి మీకు దీర్ఘకాలిక చరిత్ర అవసరమైతే ముందుగా blob storage export ను కాన్ఫిగర్ చేయండి. Langfuse సొంత పట్టికలపై మాన్యువల్గా TTL clauses రాయకండి: retention job మాత్రమే ClickHouse మరియు bucket ను సమన్వయంతో ఉంచుతుంది, మాన్యువల్ TTL ఒక వైపు మాత్రమే డేటాను తొలగిస్తుంది.
మీరు వాస్తవానికి ఉపయోగించే కాలాన్ని ఎంచుకోండి. ఖర్చు మరియు నాణ్యత సమీక్షలు రోజుల నాటి డేటాపై జరుగుతాయి, నెలల నాటి డేటాపై కాదు. చిన్న బృందానికి 30 రోజులు ప్రారంభించడానికి సరైన సమయం, ఒకవేళ ఏదైనా సమస్య వచ్చినప్పుడు మాత్రమే trace ను చూసేవారైతే 14 రోజులు సరిపోతుంది.
రెండవది ClickHouse యొక్క సొంత system log పట్టికలు. ఇది చాలామందిని ఆశ్చర్యపరుస్తుంది, ఎందుకంటే retention కాన్ఫిగర్ చేసిన తర్వాత కూడా డిస్క్ పెరుగుతూనే ఉంటుంది. ClickHouse తన సొంత డయాగ్నోస్టిక్స్ కోసం trace_log, text_log, opentelemetry_span_log, metric_log, asynchronous_metric_log మరియు latency_log లను రాస్తుంది. ఇవి ఎటువంటి TTL లేకుండా వస్తాయి మరియు Langfuse వీటిని ఎప్పుడూ చదవదు. ముందుగా డిస్క్ స్పేస్ ఎక్కడ ఖర్చవుతుందో కనుగొనండి.
SELECT table, formatReadableSize(size) AS size, rows FROM (
SELECT table, database, sum(bytes) AS size, sum(rows) AS rows
FROM system.parts
WHERE active
GROUP BY table, database
ORDER BY size DESC
)దీనిని docker compose exec clickhouse clickhouse-client --password "$CLICKHOUSE_PASSWORD" తో రన్ చేయండి. ఒకవేళ system పట్టికలు పైన కనిపిస్తే, వాటిని config overlay ద్వారా ఆపివేయండి, ఎందుకంటే ClickHouse ప్రారంభంలో /etc/clickhouse-server/config.d/ లోని ప్రతి ఫైల్ను దాని ప్రధాన కాన్ఫిగరేషన్పై మెర్జ్ చేస్తుంది.
<clickhouse>
<trace_log remove="1"/>
<text_log remove="1"/>
<opentelemetry_span_log remove="1"/>
<asynchronous_metric_log remove="1"/>
<metric_log remove="1"/>
<latency_log remove="1"/>
</clickhouse>దీనిని మౌంట్ చేసి ClickHouse ను రీస్టార్ట్ చేయండి.
services:
clickhouse:
volumes:
- ./clickhouse-config.d/system-logs.xml:/etc/clickhouse-server/config.d/system-logs.xml:roఇది కొత్త రైట్స్ను ఆపుతుంది. ఇప్పటికే డిస్క్లో ఉన్న rows అలాగే ఉంటాయి, కాబట్టి DROP TABLE IF EXISTS system.trace_log తో స్పేస్ను ఖాళీ చేయండి, మీరు తొలగించిన ప్రతి పట్టికకు ఇదే పద్ధతిని అనుసరించండి. ఒకవేళ మీరు డయాగ్నోస్టిక్స్ను ఉంచుకోవాలనుకుంటే, remove="1" కు బదులుగా ప్రతి పట్టికపై కఠినమైన TTL ను సెట్ చేయడం మరొక మార్గం, దీని గురించి Langfuse scaling డాక్యుమెంటేషన్లో వివరించబడింది. ఆ TTL ఆదేశాలు పట్టికను సృష్టించేటప్పుడే వర్తిస్తాయి, కాబట్టి ఇప్పటికే ఉన్న ఇన్స్టాలేషన్లో పట్టికలను ఎలా మార్చుకోవాలో అదే డాక్యుమెంట్లలో చూడవచ్చు.
మరొక పట్టిక గురించి తెలుసుకోవడం ముఖ్యం. blob_storage_file_log మీ bucket లోకి అప్లోడ్ చేయబడిన event ఫైళ్లను ట్రాక్ చేస్తుంది. మీరు bucket పై lifecycle policy ని సెట్ చేస్తే, ఈ పట్టికకు కూడా సరిపోయే TTL ను ఇవ్వండి, తద్వారా రెండూ వేర్వేరుగా ఉండవు.
ALTER TABLE blob_storage_file_log MODIFY TTL created_at + INTERVAL 30 DAY DELETE;డేటా డిస్క్పై ఒక సాధారణ df -h అలర్ట్ను కూడా సెట్ చేయండి. Traces సాఫీగా పెరగవు. మీరు కొత్త agent ను విడుదల చేసిన రోజున అవి పెరుగుతాయి, దానికి మొదటి సంకేతం ingestion విఫలం కాకూడదు.
Postgres మరియు ClickHouse బ్యాకప్ చేయడం
Langfuse బ్యాకప్లో మూడు భాగాలు ఉంటాయి. Postgres మీ వినియోగదారులు, సంస్థలు, ప్రాజెక్ట్లు మరియు API కీలను కలిగి ఉంటుంది. ClickHouse ట్రేస్లను (traces) కలిగి ఉంటుంది. MinIO ముడి ఈవెంట్లను (raw events) కలిగి ఉంటుంది. మీరు Postgres ను మాత్రమే పునరుద్ధరిస్తే, లాగిన్ పనిచేస్తుంది కానీ చరిత్ర (history) ఉండదు. ClickHouse ను మాత్రమే పునరుద్ధరిస్తే, చరిత్ర ఉంటుంది కానీ ఎవరూ లాగిన్ అవ్వలేరు. ఈ విభజన Langfuse కు మాత్రమే పరిమితం కాదు, self-hosted Chatwoot support desk కూడా ఇదే విధంగా ఉంటుంది; అక్కడ uploads డైరెక్టరీ లేకుండా Postgres డంప్ తీసుకుంటే, సంభాషణలు పునరుద్ధరించబడతాయి కానీ వాటిలోని అటాచ్మెంట్లు అన్నీ పోతాయి.
Postgres అనేది ఒక సాధారణ pg_dump, Docker ఇన్స్టాలేషన్ కోసం Langfuse బ్యాకప్ డాక్యుమెంటేషన్ దీనినే ఉపయోగిస్తుంది.
docker compose exec -T postgres pg_dump -U postgres postgres \
| gzip > langfuse-pg-$(date +%F).sql.gzClickHouse విషయంలో మరింత జాగ్రత్త అవసరం, ఎందుకంటే merges జరుగుతున్నప్పుడు కాపీ చేసిన డేటా డైరెక్టరీ స్థిరమైన (consistent) బ్యాకప్ కాదు. ఒకే సర్వర్లో దీనికి సులభమైన మార్గం కంటైనర్ను ఆపి, వాల్యూమ్ను ఆర్కైవ్ చేయడం.
docker compose stop clickhouse
docker volume ls | grep clickhouse
docker run --rm -v langfuse_langfuse_clickhouse_data:/data -v "$PWD":/backup alpine \
tar czf /backup/langfuse-ch-$(date +%F).tar.gz -C /data .
docker compose start clickhouseYAML లో రాసిన పేరును కాకుండా, docker volume ls ద్వారా వచ్చే వాల్యూమ్ పేరును ఉపయోగించండి. ఫైల్లో langfuse_clickhouse_data అని ఉంటుంది, Compose దానికి ప్రాజెక్ట్ పేరును ప్రిఫిక్స్గా చేరుస్తుంది, కాబట్టి langfuse అనే డైరెక్టరీలో క్లోన్ చేస్తే langfuse_langfuse_clickhouse_data అని వస్తుంది. ఇది తప్పుగా ఇస్తే, docker run ఎటువంటి హెచ్చరిక లేకుండా కొత్త ఖాళీ వాల్యూమ్ను సృష్టిస్తుంది, తద్వారా మీ ఆర్కైవ్లో ఏమీ ఉండదు.
Langfuse ప్రతి ingestion అభ్యర్థనపై ముడి ఈవెంట్ డేటాను బకెట్లోకి అప్లోడ్ చేస్తుంది మరియు విఫలమైన ingestion పనులను మళ్ళీ ప్రయత్నించడానికి దానిని తిరిగి చదువుతుంది, కాబట్టి ClickHouse ను కొద్దిసేపు ఆపడం వల్ల worker ఆ తర్వాత మళ్ళీ ప్రయత్నిస్తుంది. ట్రాఫిక్ తక్కువగా ఉన్న సమయంలో దీన్ని చేయండి మరియు త్వరగా పూర్తి చేయండి. ఎక్కువ ట్రాఫిక్ ఉన్న ఇన్స్టాన్స్ కోసం, ClickHouse యొక్క సొంత BACKUP DATABASE default TO S3(...) స్టేట్మెంట్ సర్వర్ను ఆపకుండానే స్థిరమైన బ్యాకప్ను రూపొందిస్తుంది. MinIO మూడవ భాగం, దీని కోసం mc mirror లేదా MinIO replication ను ఉపయోగించి వేరే సర్వర్కు కాపీ చేయడం ద్వారా భద్రపరచవచ్చు. మీరు దేనిని బ్యాకప్ చేసినా, దానిని సర్వర్ నుండి బయటకు పంపండి, దీని కోసమే VPS పై encrypted restic backups ఉపయోగపడతాయి.
Redis క్యూ మరియు కాష్ను కలిగి ఉంటుంది. ఇది పోతే క్యూలో ఉన్న పనులు పోతాయి, బకెట్లో ముడి ఈవెంట్ ఫైళ్లు ఉన్నప్పటికీ ఇది జరుగుతుంది.
స్థిరత్వానికి సంబంధించిన హెచ్చరిక వాస్తవమైనది మరియు దీనిని స్పష్టంగా చెప్పాలి. Postgres మరియు ClickHouse వేర్వేరు సమయాల్లో డంప్ చేయబడతాయి, కాబట్టి పునరుద్ధరణ చేసినప్పుడు ట్రేస్లు లేని ప్రాజెక్ట్ రో (row) ఉండవచ్చు లేదా ఉనికిలో లేని ప్రాజెక్ట్కు చెందిన ట్రేస్లు ఉండవచ్చు. Langfuse దీనిని తట్టుకోగలదు, కానీ రెండు డంప్లను దగ్గరి సమయాల్లో మరియు తక్కువ ట్రాఫిక్ ఉన్నప్పుడు తీసుకోండి. ఈవెంట్ బకెట్ నిజమైన భద్రతా వలయం, ఎందుకంటే Langfuse ప్రతి ingestion అభ్యర్థనపై ముడి ఈవెంట్ డేటాను అక్కడ అప్లోడ్ చేస్తుంది.
కనీసం ఒక్కసారైనా కొత్త stack లో పునరుద్ధరణను పరీక్షించండి. అప్పుడే మీకు వాల్యూమ్ పేరు తప్పుగా ఉంటే తెలుస్తుంది, లేదంటే సర్వర్ పనిచేయనప్పుడు ఇబ్బంది పడాల్సి వస్తుంది.
మొదట పరిశీలించాల్సినవి
మొదటి వారంలో ఈ నాలుగు అంశాలను తప్పక పరిశీలించాలి.
- Trace ఒక్కదానికి అయ్యే ఖర్చు. Langfuse model పేరు మరియు token వినియోగం ఆధారంగా ఖర్చును లెక్కిస్తుంది. అందువల్ల traceలను ఖర్చు ఆధారంగా క్రమబద్ధీకరించి, అత్యధిక ఖర్చు ఉన్న traceను ప్రారంభం నుంచి ముగింపు వరకు చదవండి. సాధారణంగా కారణం పెరిగిపోయిన prompt అవుతుంది: మొత్తం documentను contextలో paste చేయడం లేదా ఎవరూ కుదించని conversation history. కారణం కనిపించిన తర్వాత, AI agent మీకు అయ్యే ఖర్చును నియంత్రించడం అంచనాపై కాకుండా engineering పనిగా మారుతుంది.
- Input మరియు output ఆధారంగా విభజించిన token వినియోగం. Input tokens ఎక్కువగా ఉంటాయి మరియు తక్కువ ఖర్చు అవుతాయి. Output tokens తక్కువగా ఉంటాయి మరియు ఎక్కువ ఖర్చు అవుతాయి. Cached input ఇంకా తక్కువ ఖర్చుతో ఉంటుంది. ఇదే లెక్కింపు విధానాన్ని Claude Code token వినియోగం ఎలా లెక్కించబడుతుంది లో వివరించారు. మీరు స్వయంగా రాసే ఏ agentకైనా ఇది వర్తిస్తుంది.
- Latency percentiles. Median సమస్యను దాచిపెడుతుంది. Timeouts సాధారణంగా p95 మరియు p99 వద్ద కనిపిస్తాయి. Agent loopలో p95 వద్ద నెమ్మదిగా జరిగే tool call, iterations సంఖ్యకు అనుగుణంగా మొత్తం ఆలస్యాన్ని పెంచుతుంది.
- విఫలమైన tool calls. Observationsను level
ERRORఆధారంగా filter చేయండి. 5% సందర్భాల్లో విఫలమయ్యే tool aggregate success rateలో కనిపించకపోవచ్చు. కానీ tracesలో అది స్పష్టంగా కనిపిస్తుంది. అక్కడ model మళ్లీ ప్రయత్నించి, ఆ తరువాత ఆ toolను పక్కదారి ద్వారా ఉపయోగించడానికి tokens ఖర్చు చేస్తుంది.
Retention windowను నిర్ణయించండి. Deploy చేసే రోజే, ప్రతి వారం పరిశీలించే dashboardను ఎంచుకోండి. ఎవరూ తెరవని observability tool diskను నింపే databaseగా మారుతుంది.
FAQ
self-hosted Langfuse కు ఎంత మెమరీ అవసరం?
4 CPU కోర్లు మరియు 16 GiB మెమరీని ప్లాన్ చేసుకోండి. ఒకే virtual machine పై Langfuse Docker Compose గైడ్ సిఫార్సు చేసేది ఇదే, దీనికి అదనంగా సుమారు 100 GiB స్టోరేజ్ అవసరం. ప్రచురించబడిన కనీస అవసరాల ప్రకారం ClickHouse కోసం 8 GiB, web మరియు worker కంటైనర్లలో ప్రతిదానికి 4 GiB అవసరం. అదే పేజీలో Postgres కోసం 4 GiB, Redis కోసం 1.5 GiB మరియు MinIO కోసం 4 GiB పేర్కొన్నారు. ఈ ఆరు కలిపితే మొత్తం 25.5 GiB అవుతుంది, ఇది Compose సిఫార్సు చేసిన 16 GiB కంటే ఎక్కువ.
డేటా రిటెన్షన్ సెట్ చేసిన తర్వాత కూడా నా ClickHouse డిస్క్ ఎందుకు నిండిపోతోంది?
రిటెన్షన్ సెట్టింగ్ Langfuse సొంత డేటాకు మాత్రమే వర్తిస్తుంది. ClickHouse విడిగా trace_log, text_log, opentelemetry_span_log, metric_log, asynchronous_metric_log మరియు latency_log వంటి డయాగ్నోస్టిక్ టేబుళ్లను రాస్తుంది, వీటికి ఎటువంటి TTL ఉండదు. ఏ టేబుల్ ఎక్కువ స్థలాన్ని ఆక్రమిస్తుందో చూడటానికి system.parts క్వెరీని టేబుల్ వారీగా గ్రూప్ చేసి రన్ చేయండి. ఆ తర్వాత /etc/clickhouse-server/config.d/ లోని ఫైల్లో remove="1" ఎంట్రీ ద్వారా ఉపయోగించని టేబుళ్లను డిసేబుల్ చేయండి. ClickHouse ను రీస్టార్ట్ చేసి, ఇప్పటికే ఆక్రమించిన స్థలాన్ని తిరిగి పొందడానికి పాత టేబుళ్లను డ్రాప్ చేయండి.
Langfuse లో కనీస డేటా రిటెన్షన్ కాలపరిమితి ఎంత?
మూడు రోజులు. రిటెన్షన్ను ప్రాజెక్ట్ సెట్టింగ్స్లో లేదా Organization Management API ద్వారా సెట్ చేయవచ్చు. ప్రతి రాత్రి రన్ అయ్యే జాబ్, సేవ్ చేసిన డేటాసెట్ ఐటమ్స్తో సంబంధం ఉన్న మీడియా మినహా, నిర్ణీత కాలపరిమితి కంటే పాతవైన traces, observations, scores మరియు media assets ను ClickHouse మరియు blob storage రెండింటి నుండి తొలగిస్తుంది. self-hosted ఇన్స్టాన్స్లో ఇది Enterprise Edition ఫీచర్, దీనికి లైసెన్స్ కీ అవసరం. లైసెన్స్ కీ లేకపోతే, డేటా శాశ్వతంగా నిల్వ ఉంటుంది. తొలగించిన డేటాను తిరిగి పొందలేము, కాబట్టి ఆ కాలపరిమితి కంటే ఎక్కువ చరిత్ర అవసరమైతే ముందుగా blob storage ఎక్స్పోర్ట్ను కాన్ఫిగర్ చేసుకోండి.
నేను Postgres మరియు ClickHouse రెండింటినీ బ్యాకప్ చేయాలా?
అవును, ఎందుకంటే అవి వేర్వేరు సమాచారాన్ని కలిగి ఉంటాయి. Postgres లో యూజర్లు, సంస్థలు, ప్రాజెక్టులు మరియు API కీలు ఉంటాయి, ClickHouse లో trace డేటా ఉంటుంది. కేవలం Postgres ను మాత్రమే రీస్టోర్ చేస్తే, మీరు లాగిన్ అవ్వగలరు కానీ లోపల ఏ డేటా ఉండదు. MinIO బకెట్ను కూడా బ్యాకప్ చేయండి, ఎందుకంటే Langfuse కు డేటా వచ్చినప్పుడు అది నేరుగా అందులోనే నిల్వ అవుతుంది. ఇది ఈ స్టాక్లో అసలైన డేటాకు అత్యంత దగ్గరగా ఉండే మూలం.
ఇప్పటికే ఉన్న OpenTelemetry సెటప్ను self-hosted Langfuse కు అనుసంధానించవచ్చా?
అవును. Langfuse v4 మరియు దాని ప్రస్తుత SDKలు OpenTelemetry పై నిర్మించబడ్డాయి. Anthropic మరియు OpenAI OTel ఇన్స్ట్రుమెంటేషన్లు నేరుగా దీనికే ఎక్స్పోర్ట్ చేస్తాయి. Python లో, pip install langfuse opentelemetry-instrumentation-anthropic రన్ చేయండి, స్టార్టప్లో ఒకసారి AnthropicInstrumentor().instrument() ని కాల్ చేయండి, మరియు LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL లను మీ స్వంత హోస్ట్కు సెట్ చేయండి. డాష్బోర్డ్ కనిపించకపోతే వెతకడానికి ముందు langfuse.auth_check() తో నిర్ధారించుకోండి.