Nas

thanks for taking the time to respond guys, as shown in the image the 2 message work around is good enough for now .. Will keep an eye on the issue for updates regarding the reasoning support.

Thanks for the suggestions! Unfortunately the suggested approach doesn't work in Phoenix 12.6.1. What Didn't Work Suggested code:

client = px.Client(endpoint="http://localhost:6006")
corpus_inferences = px.Inferences(corpus_df, corpus_schema, "corpus")
client.log_inferences(corpus_inferences)  # ← Method doesn't exist

Issue: client.log_inferences() doesn't exist in Phoenix 12.6.1. Available methods are: - log_evaluations(), log_traces(), upload_dataset() - query_spans(), get_spans_dataframe() - No method to log Inferences to a running instance Also tried: - px.log_inferences() - doesn't exist - px.launch_app(corpus=...) - corpus loads in backend but doesn't appear in /model UI - px.launch_app(primary=..., corpus=...) - /model tab appears, but OTEL trace embeddings don't show in the UMAP view Working Solution: 2-Instance Approach Instance 1 (port 6006): Trace collector receiving OTEL spans with embeddings Instance 2 (port 7007): UMAP viewer that: 1. Queries Instance 1 for trace spans 2. Extracts query embeddings from attributes.embedding.embeddings 3. Extracts retrieval links from attributes.retrieval.documents 4. Loads corpus from LanceDB 5. Launches separate Phoenix with both as Inferences Code:

# Extract queries from trace collector
client = px.Client(endpoint="http://localhost:6006")
spans = client.query_spans(project_name="my-project")

# Parse embeddings and retrieval links from spans
query_df = extract_queries_with_metadata(spans, source_page_to_id)

# Load corpus
corpus_df = load_from_lancedb()

# Define schemas with retrieval links
query_schema = px.Schema(
    prompt_column_names=px.RetrievalEmbeddingColumnNames(
        vector_column_name="vector",
        raw_data_column_name="question",
        context_retrieval_ids_column_name="retrieved_document_ids",  # Links!
    ),
)

corpus_schema = px.Schema(
    id_column_name="document_id",
    document_column_names=px.EmbeddingColumnNames(
        vector_column_name="vector",
        raw_data_column_name="text",
    ),
)

# Launch UMAP viewer
session = px.launch_app(
    port=7007,
    primary=px.Inferences(query_df, query_schema, "queries"),
    corpus=px.Inferences(corpus_df, corpus_schema, "corpus"),
)

Result: http://localhost:7007/model shows UMAP with corpus + queries + retrieval links ✅ Current workflow:

# Run queries -> restart viewer to see updates
python rag_cli.py --trace query my-collection "question" --k 3
lsof -ti:7007 | xargs -r kill -9
python phoenix_umap_enhanced_metadata.py  # Re-extracts & relaunches

Core Question (open to be answered by all) Is there a way in Phoenix UI to visualise trace embeddings in UMAP, or is manual extraction the intended workflow? Looking at the https://arize.com/docs/ax/evaluate/evaluation-concepts/retrieval-evaluation, even official examples manually load embeddings with EmbeddingColumnNames. What I'm hoping exists: - A UI feature to visualize attributes.embedding.embeddings from traces in UMAP - Auto-population: corpus from Inferences + queries from incoming OTEL traces - Refresh browser to see updated UMAP (no script restart) If manual extraction is the recommended pattern, that's totally fine! Just want to confirm I'm not missing a more elegant built-in approach.

how exactly do i log corpus embeddings to Docker Phoenix, this is the sticking point for me RunLLM

retrieval-with-embeddings.md had the info i needed, thanks.... Currently using two separate Phoenix instances and wondering if there's a better approach. Current Setup: - Docker Phoenix (port 6006): Collecting OTEL traces from queries - Has query embeddings (from attributes.embedding.embeddings) - Has retrieval metadata (from attributes.retrieval.documents) - From what i can tell, does NOT have corpus embeddings - Separate px.launch_app() (port 7007): UMAP visualization - Queries Docker Phoenix to extract query embeddings - Loads corpus embeddings from LanceDB - Uses RetrievalEmbeddingColumnNames with context_retrieval_ids_column_name to create links - Shows UMAP with query→corpus retrieval connections My next Questions: 1. Is there a way to use Docker Phoenix's built-in UMAP viewer instead of launching a separate instance? - I saw "Embeddings Tracing lets you select embedding spans and dive into UMAP visualizer" - does this support corpus embeddings + retrieval links? - Can I log corpus embeddings to Docker Phoenix so everything's in one place? 2. What's the recommended development workflow for iterative testing? - Currently: Run queries > Kill UMAP viewer > restart to see new data - Is there an auto-refresh or live-update approach for embeddings visualisation? To summarise want to know if I can use Docker Phoenix's built-in UMAP viewer instead of launching a separate instance. If two instances is the right approach, any tips for the refresh workflow RunLLM?