Month: November 2026

This week’s Java roundup for October 26th, 2026, features news highlighting: the GA release of TornadoVM 8.0; point releases of JNoSQL, Endive, JBang, JReleaser and LangChain4j; a maintenance release of JobRunr; beta releases of Hibernate ORM and Hibernate Reactive; and introducing the Quarkus Almanac.

JDK 28

Build 22 of the JDK 28 early-access builds was made available this past week featuring updates from Build 21 that include fixes for various issues. More details on this release may be found in the release notes.

For JDK 28, developers are encouraged to report bugs via the Java Bug Database.

TornadoVM

The release of TornadoVM 8.0.0 delivers their new pure-Java compiler, known as the TornadoVM Compiler (TC), that compiles Java kernels to CUDA C++, OpenCL C or Metal Shading Language. This replaces the Graal Compiler and Java-Level JVM Compiler Interface (JVMCI) that have been integral to TornadoVM for the past ten years. Developers won’t need to change their code with TC. Classes such as TaskGraph, TornadoExecutionPlan and KernelContext, and annotations such as @Parallel and @Reduce will work with TC.

TornadoVM now takes advantage of GraalVM Native Image and JEP 516, Ahead-of-Time Object Caching with Any GC, under the auspices of Project Leyden for improved startup time. Further details on this release may be found in the release notes.

Eclipse JNoSQL

The release of Eclipse JNoSQL 1.2.0, a compatible implementation of the Jakarta NoSQL and Jakarta Data specifications, ships with notable changes such as: a new VectorTemplate interface to support vector databases; integrations of the Milvus, Qdrant, and Weaviate vector databases for vector search; and new fluent temporal query operations for working with time-series data. More details on this release may be found in the release notes.

Endive

The release of Endive 1.2.0 provides bug fixes, dependency upgrades and new features such as: support for SIMD instructions, by default, in the interpreter on JDK 11+ without the need to add or configure; improvements to Redline, their experimental, ahead-of-time (AOT) compiler, for more GC-friendly native memory; and continuous improvement on the Endive Component Model, an implementation of the WebAssembly Component Model Design and Specification, to support the Endive runtime. Further details on this release may be found in the release notes.

JBang

The release of JBang 0.143.0 delivers bug fixes, documentation improvements and two new features: replace use of SDKMan with mise-en-place as the former does not support WindowsOS; and a new unified syntax to execute a specific version of an alias. More details on this release may be found in the release notes.

JReleaser

The release of JReleaser 1.27.0 ships with bug fixes, documentation improvements, dependency upgrades and new features such as: the ability for the support for the JReleaser Tool Provider to be invoked and/or loaded using Java Modules; improved generation of the changelog when GitHub issues are linked inside commit messages; and the removal of XPath to parse POM files as there were issues when packaging JReleaser as a native image. Further details on this release may be found in the release notes.

LangChain4j

The formal release (along with the thirty-third beta release) of LangChain4j 1.23.0 provides bug fixes, documentation improvements, dependency upgrades and new features such as: a new OllamaDecisionModel class to support decision models running in Ollama; and a new ConfidenceCascadePlanner class as a confidence cascade decision model-based agentic pattern. More details on this release may be found in the release notes.

Hibernate

The fourth beta release of Hibernate ORM 8.0.0 delivers bug fixes and notable changes such as: the ability to directly declare the @Filter and @SQLRestriction annotations on associations with the Jakarta Persistence @ManyToOne and @OneToOne annotations that include associations mapped using join tables; and a new @GeneratorOptimizer annotation that selects a “standard optimizer for sequence or table identifier generation directly on an identifier field or getter.“

The first and third beta releases of Hibernate Reactive 5.1.0 and 5.0.0, respectively, ship with bug fixes and notable changes such as: a new platform Bill of Materials that manages the versions of Hibernate Reactive, Hibernate ORM and Vert.x SQL clients; and a version check during bootstrap to ensure that Hibernate ORM and Vert.x SQL clients on the classpath aren’t older than the minimum versions it supports. Both of these versions are compatible with Hibernate ORM 8.0.0.Beta4.

JobRunr

The release of JobRunr 9.0.3 provides bug fixes, documentation improvements and dependency upgrades and one new feature that updates the JobHandler class that improves the log messaging from the JobZooKeeper class. Further details on this release may be found in the release notes.

Gradle

The first release candidate of Gradle 9.9.0 delivers notable changes such as: the ability for Kotlin DSL scripts to be incrementally compiled using the Kotlin Build Tools API for improved build performance; new test filters that may be applied to JUnit Platform tests that are not declared as methods; and improvements to the Problems API that provides a predefined hierarchy of problem groups from the Problems interface. More details on this release may be found in the release notes.

Quarkus Almanac

The Quarkus team has introduced the Quarkus Almanac, a utility for developers to compare changes between two releases. These changes include configuration properties, managed dependencies, extensions, and the API of the classes in the Quarkus jars. Developers can go as far back as November 2018 when Quarkus 0.0.1 was released.

MongoDB公司(MDB-US)截至台北時間02日23:01股價下跌17.84美元，報335.13美元，跌幅5.05%，成交量176,509（股），盤中最高價352.06美元、最低價335.00美元。

美股指數盤中表現

• 道瓊指數：+0.97%
• S&P 500指數：+0.59%
• NASDAQ指數：+0.73%
• 費城半導體指數：+0.41%

MongoDB公司(MDB-US)歷史漲跌幅

• 近 1 週：-4.89%
• 近 1 月：+0.35%
• 近 3 月：+4.59%
• 近 6 月：+33.97%
• 今年以來：-15.9%

更多鉅亨報導

What happened?

A number of stocks fell in the morning session after software stocks extended the selloff from the previous session as investors continued to reprice valuations amid mounting artificial intelligence capital expenditure concerns and decelerating software bookings. 

Oracle filed to raise $20 billion in debt and equity, reigniting concerns over soaring artificial intelligence spending and cash burn. The selloff deepened after quarterly reports from Alphabet and Amazon highlighted soaring data-center outlays that compressed free cash flows, as reported by Bloomberg. That spending concern triggered the tech-heavy Nasdaq’s drop the previous week, cementing its steepest monthly decline in over a year, according to The Wall Street Journal. 

Investors are increasingly demanding clear evidence that massive infrastructure outlays will translate into sustainable profits and robust revenue growth. Without immediate monetization from enterprise adoption, concerns over elevated sector valuations have deepened, leading to broad-based selling pressure across chipmakers, hardware providers, and cloud service operators.

The stock market overreacts to news, and big price drops can present good opportunities to buy high-quality stocks.

Among others, the following stocks were impacted:

Zooming in on JFrog (FROG)

JFrog’s shares are extremely volatile and have had 45 moves greater than 5% over the last year. In that context, today’s move indicates the market considers this news meaningful but not something that would fundamentally change its perception of the business.

The previous big move we wrote about was 3 days ago when the stock dropped 8.8% on the news that underwhelming earnings reports from tech giants Amazon and Intel (after mediocre earnings reports from Alphabet and ServiceNow the previous day) sparked widespread investor anxiety regarding aggressive artificial intelligence spending and sustained cash burn. As reported by CNBC, disappointing quarterly reports from both companies triggered a broad slide across technology equities and hardware suppliers, overshadowing positive momentum in other areas of the market. Investors grew increasingly wary of the sector’s rising capital expenditures—the funds poured into long-term assets such as data centers and computing hardware. With both firms spending heavily to build out artificial intelligence infrastructure, market participants are questioning when these massive investments will translate into meaningful revenue and profit growth per CNBC. The steep drops in Amazon and Intel weighed heavily on market indices, showing how vulnerabilities among dominant technology leaders can rapidly dampen confidence across the broader industry.

JFrog is up 48.7% since the beginning of the year, but at $88.55 per share, it is still trading 14.9% below its 52-week high of $104.03 from August 2026. Investors who bought $1,000 worth of JFrog’s shares 5 years ago would now be looking at an investment worth $2,692.

WHILE YOU’RE HERE: The Next Palantir? One satellite company captures images of every point on Earth. Every single day. The Pentagon wants it. Hedge funds are using it to beat earnings. You’ve probably never heard of it.

This is what the early days of Palantir looked like before it became a giant. Same playbook. Different technology. If you missed Palantir, you need to see this. Claim The Stock Ticker for Free HERE.

TorchTPU is an open-source project developed by Google in collaboration with Meta that provides a native PyTorch backend for Google TPUs. It enables PyTorch workloads to execute on TPU hardware with minimal code modifications, supporting eager and compiled execution, distributed computing, and hardware-specific optimizations.

Google began enabling PyTorch workloads to run on TPUs in 2020 through PyTorch/XLA, which leveraged JAX, XLA, and lazy tensors. According to Google, this approach had significant shortcomings:

Crucially, PyTorch/XLA required intrusive source-code modifications to explicitly define compilable regions, suffered from severe compile-time latency, lacked support for PyTorch’s native imperative (“eager”) execution mode, and lagged in supporting emerging distributed computing primitives within the PyTorch ecosystem.

TorchTPU takes a fundamentally different approach, making eager execution a top priority, and enabling existing PyTorch workloads to run out with minor code modifications.

Specifically, migrating from GPUs to TPUs involves replacing the cuda device with tpu and the nccl distributed backend with tpu_dist. Alternatively, developers can use the new torch.accelerator.current_accelerator API to identify the available accelerator, as shown in the following snippet.

import torch
import torch.distributed as dist

def main():
    device = torch.device("cuda") # -> device = torch.accelerator.current_accelerator
    dist.init_process_group(backend="nccl") # -> dist.init_process_group()
    rank = dist.get_rank()
    word_size = dist.get_world_size()
    ...
    model = model.to(device)
    ...

TorchTPU support three eager execution modes: strict, debug, and DeferAndFuse. The latter is a new hybrid eager/compiled execution mode that Google claims “can be 50% or more faster than Strict Eager while reducing peak HBM memory”.

To test TorchTPU’s ability to run existing PyTorch models with no modifications, Google built an integration pipeline to evaluate about 5,000 Hugging Face models across 500+ architectures in both eager and compiled modes on TPU hardware generations starting from v5e.

We use a robust testing methodology grounded in corpus stratification and balanced architectural selection. Our approach relies on a two-tiered selection process designed to balance real-world adoption with broad architectural diversity, avoiding redundant testing of minor variations while ensuring real production weights are thoroughly evaluated.

To validate TorchTPU’s performance, Google ran a 30-billion parameter Muse Glimmer model implemented in standard PyTorch. On a single TPUv7 chip, inference throughput reached 25.7k token/s at 5120 sequence length and 22.4k token/s at 10,240 sequence length. For training, using four TPUv7 chips, throughput reached 5.6k token/s and 4.6k token/s at 5120 and 10,240 sequence length, respectively.

Google also conducted experiments using Qwen3 MoE 235B for training workloads, scaling from 1,024 to 8,192 TPUv7 chips. For inference, Google reported competitive performance-per-dollar for large-scale MoE workloads using vLLM.

Commenting on the announcement, Hacker News user tingkuanpei observed:

Very interesting work. Google should have done this a long time ago. PyTorch’s ecosystem is just so rich.

Other users pointed out that beyond offering TPUs through GCP, Google sells them to “enterprise client for on premises deployments”, which include Anthropic and in Meta following potentially in the future.

TorchTPU is still at an early stage and therefore in continuous evolution. The project’s roadmap include work on dynamic shapes, compilation performance, operator coverage, reinforcement learning, and quantization. For further details, make sure to read the original announcement, which provides a more comprehensive view of TorchTPU’s architecture and scope.

This week’s Java roundup for October 26th, 2026, features news highlighting: the GA release of TornadoVM 8.0; point releases of JNoSQL, Endive, JBang, JReleaser and LangChain4j; a maintenance release of JobRunr; beta releases of Hibernate ORM and Hibernate Reactive; and introducing the Quarkus Almanac.

JDK 28

Build 22 of the JDK 28 early-access builds was made available this past week featuring updates from Build 21 that include fixes for various issues. More details on this release may be found in the release notes.

For JDK 28, developers are encouraged to report bugs via the Java Bug Database.

TornadoVM

The release of TornadoVM 8.0.0 delivers their new pure-Java compiler, known as the TornadoVM Compiler (TC), that compiles Java kernels to CUDA C++, OpenCL C or Metal Shading Language. This replaces the Graal Compiler and Java-Level JVM Compiler Interface (JVMCI) that have been integral to TornadoVM for the past ten years. Developers won’t need to change their code with TC. Classes such as TaskGraph, TornadoExecutionPlan and KernelContext, and annotations such as @Parallel and @Reduce will work with TC.

TornadoVM now takes advantage of GraalVM Native Image and JEP 516, Ahead-of-Time Object Caching with Any GC, under the auspices of Project Leyden for improved startup time. Further details on this release may be found in the release notes.

Eclipse JNoSQL

The release of Eclipse JNoSQL 1.2.0, a compatible implementation of the Jakarta NoSQL and Jakarta Data specifications, ships with notable changes such as: a new VectorTemplate interface to support vector databases; integrations of the Milvus, Qdrant, and Weaviate vector databases for vector search; and new fluent temporal query operations for working with time-series data. More details on this release may be found in the release notes.

Endive

The release of Endive 1.2.0 provides bug fixes, dependency upgrades and new features such as: support for SIMD instructions, by default, in the interpreter on JDK 11+ without the need to add or configure; improvements to Redline, their experimental, ahead-of-time (AOT) compiler, for more GC-friendly native memory; and continuous improvement on the Endive Component Model, an implementation of the WebAssembly Component Model Design and Specification, to support the Endive runtime. Further details on this release may be found in the release notes.

JBang

The release of JBang 0.143.0 delivers bug fixes, documentation improvements and two new features: replace use of SDKMan with mise-en-place as the former does not support WindowsOS; and a new unified syntax to execute a specific version of an alias. More details on this release may be found in the release notes.

JReleaser

The release of JReleaser 1.27.0 ships with bug fixes, documentation improvements, dependency upgrades and new features such as: the ability for the support for the JReleaser Tool Provider to be invoked and/or loaded using Java Modules; improved generation of the changelog when GitHub issues are linked inside commit messages; and the removal of XPath to parse POM files as there were issues when packaging JReleaser as a native image. Further details on this release may be found in the release notes.

LangChain4j

The formal release (along with the thirty-third beta release) of LangChain4j 1.23.0 provides bug fixes, documentation improvements, dependency upgrades and new features such as: a new OllamaDecisionModel class to support decision models running in Ollama; and a new ConfidenceCascadePlanner class as a confidence cascade decision model-based agentic pattern. More details on this release may be found in the release notes.

Hibernate

The fourth beta release of Hibernate ORM 8.0.0 delivers bug fixes and notable changes such as: the ability to directly declare the @Filter and @SQLRestriction annotations on associations with the Jakarta Persistence @ManyToOne and @OneToOne annotations that include associations mapped using join tables; and a new @GeneratorOptimizer annotation that selects a “standard optimizer for sequence or table identifier generation directly on an identifier field or getter.“

The first and third beta releases of Hibernate Reactive 5.1.0 and 5.0.0, respectively, ship with bug fixes and notable changes such as: a new platform Bill of Materials that manages the versions of Hibernate Reactive, Hibernate ORM and Vert.x SQL clients; and a version check during bootstrap to ensure that Hibernate ORM and Vert.x SQL clients on the classpath aren’t older than the minimum versions it supports. Both of these versions are compatible with Hibernate ORM 8.0.0.Beta4.

JobRunr

The release of JobRunr 9.0.3 provides bug fixes, documentation improvements and dependency upgrades and one new feature that updates the JobHandler class that improves the log messaging from the JobZooKeeper class. Further details on this release may be found in the release notes.

Gradle

The first release candidate of Gradle 9.9.0 delivers notable changes such as: the ability for Kotlin DSL scripts to be incrementally compiled using the Kotlin Build Tools API for improved build performance; new test filters that may be applied to JUnit Platform tests that are not declared as methods; and improvements to the Problems API that provides a predefined hierarchy of problem groups from the Problems interface. More details on this release may be found in the release notes.

Quarkus Almanac

The Quarkus team has introduced the Quarkus Almanac, a utility for developers to compare changes between two releases. These changes include configuration properties, managed dependencies, extensions, and the API of the classes in the Quarkus jars. Developers can go as far back as November 2018 when Quarkus 0.0.1 was released.

The downturn occurred in tandem with weakness across related cloud, developer, and data platform equities. Peer companies including Datadog, Snowflake, Bandwidth, and DigitalOcean also traded lower, indicating that institutional flows were retreating from the broader cloud infrastructure complex rather than responding to an isolated catalyst at MongoDB itself. Without a confirmed company-specific release such as an earnings announcement or product shift, the sell-off aligned with a synchronized retreat among high-multiple technology equities.

Market participants continue to evaluate software valuations against ongoing macroeconomic uncertainties and enterprise IT spending trends. High-growth software providers remain sensitive to shifts in market appetite, where broader risk-off adjustments frequently prompt rapid multiple contraction across the peer group. Heightened competition within the cloud database space alongside ongoing sector-wide spending scrutiny continues to present fundamental hurdles for valuation expansion across growth names.

From a technical perspective, the decline pushes the stock lower within its recent trading range, drawing market attention toward key support zones established in prior consolidations. The failure to maintain recent momentum highlights the vulnerability of the peer group to broader sector rotations. Market participants are watching to see if trading interest stabilizes around these reduced price levels or if continued weakness across cloud peers leads to additional downward pressure.

MongoDB公司(MDB-US)截至台北時間02日23:01股價下跌17.84美元，報335.13美元，跌幅5.05%，成交量176,509（股），盤中最高價352.06美元、最低價335.00美元。

美股指數盤中表現

• 道瓊指數：+0.97%
• S&P 500指數：+0.59%
• NASDAQ指數：+0.73%
• 費城半導體指數：+0.41%

MongoDB公司(MDB-US)歷史漲跌幅

• 近 1 週：-4.89%
• 近 1 月：+0.35%
• 近 3 月：+4.59%
• 近 6 月：+33.97%
• 今年以來：-15.9%

更多鉅亨報導

Services by Moomoo Technologies Inc.

How to replace LangChain’s in-memory chat history with ScyllaDB — so your RAG chatbot retains context across restarts and scales across replicas

This post demonstrates how to integrate ScyllaDB Vector Search into your LangChain project for RAG use cases, as well as how to use ScyllaDB as a durable conversation memory within LangChain.

Background

Large language models are trained on a fixed snapshot of the world. RAG patches that gap by retrieving relevant documents at query time and injecting them into the prompt. The pipeline has two phases:

• Index: load documents, split them into chunks, embed each chunk, store embeddings in a vector store.
• Retrieve & Generate: enrich and embed the user’s question, find the nearest vectors (ANN search), pass the matching chunks as context to the LLM.

But RAG alone is not enough. You still need to keep track of all inputs provided by the user.

Persistent Chat Memory

LLMs are stateless. Every call starts with a blank slate unless you replay the conversation history. LangChain’s BaseChatMessageHistory abstraction lets you plug in any backend as the storage layer for that history. The default in-memory implementation vanishes on process exit. A database-backed implementation survives restarts, scales across replicas, and lets you inspect or audit conversations later.

That’s where ScyllaDB comes in.

ScyllaDB + LangChain

ScyllaDB is a NoSQL database optimized for high-throughput, low-latency workloads. Combined with LangChain, you can build reliable and always-on AI applications:

• High availability: data is automatically replicated across nodes, so there is no single point of failure. The cluster continues serving reads and writes even if a node goes down.
• Predictable P99 latency: ANN queries return results fast enough that retrieval doesn’t dominate your chain’s total latency.
• Horizontal scalability: add nodes to the cluster to increase throughput without schema changes or downtime.
• Built-in vector search: a native vector<float, N> type and HNSW index are created automatically in ScyllaDB.

In this example, embeddings are generated locally with sentence-transformers (all-MiniLM-L6-v2, 384 dimensions). For production use, you can swap in OpenAI embeddings, Cohere, or any other provider supported by LangChain.

In each conversation turn, the chatbot is reading data from ScyllaDB and then writing back into it using LangChain.

Setup Example

With the release of ScyllaDB 2026.2, you can now integrate LangChain with ScyllaDB seamlessly by reusing the existing Cassandra connector.

Install Dependencies

pip install langchain langchain-community 
    sentence-transformers langchain-groq 
    langchain-text-splitters cassio 
    scylla-driver python-dotenv

Environment Variables

Copy demo/.env.example to demo/.env and fill in your credentials:

# ScyllaDB Cloud
SCYLLADB_CONTACT_POINTS=node-0.your-cluster.cloud.scylladb.com
SCYLLADB_DATACENTER=AWS_US_EAST_1
SCYLLADB_USERNAME=scylla
SCYLLADB_PASSWORD=your-password-here
SCYLLADB_KEYSPACE=demo

# Groq (LLM)
GROQ_API_KEY=gsk_...

Retrieve the contact points, datacenter name, username, and password from the Connect tab of your cluster in ScyllaDB Cloud.

Connect to ScyllaDB Cloud

from cassandra.cluster import Cluster
from cassandra.auth import PlainTextAuthProvider
from cassandra.policies import DCAwareRoundRobinPolicy
import cassio

cluster = Cluster(
    contact_points=["node-0.your-cluster.cloud.scylladb.com"],
    auth_provider=PlainTextAuthProvider(
        "scylla", "your-password"
    ),
    load_balancing_policy=DCAwareRoundRobinPolicy(
        local_dc="AWS_US_EAST_1"
    ),
)

session = cluster.connect()
cassio.init(session=session, keyspace="demo")

The cassio.init() call registers the session and keyspace globally so all downstream integrations (the vector store and the chat history) pick it up without further configuration.

Although cassio was originally built as a Cassandra integration, it is session-agnostic. It works with whatever driver session you hand it, so passing a session created by scylla-driver works just as well.

Integrating ScyllaDB with LangChain Vector Store

As an example, consider a chatbot that ingests articles, answers questions using retrieved context, and preserves conversation history in the database.

from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Cassandra

loader = WebBaseLoader([
    "https://docs.scylladb.com/stable/get-started/scylladb-basics.html",
    "https://docs.scylladb.com/stable/get-started/data-modeling/query-design.html",
])
docs = loader.load()

chunks = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
).split_documents(docs)

embeddings = HuggingFaceEmbeddings(
    model_name="all-MiniLM-L6-v2"
)

vectorstore = Cassandra(
    embedding=embeddings,
    table_name="rag_docs"
)
vectorstore.add_documents(chunks)

retriever = vectorstore.as_retriever(
    search_kwargs={"k": 4}
)

WebBaseLoader fetches and parses each URL into a Document.

RecursiveCharacterTextSplitter then breaks each document into 500-token chunks with a 50-token overlap so sentences are not severed at boundaries.

Cassandra(table_name="rag_docs") creates the table on first use, including a vector<float, 384> column (matching all-MiniLM-L6-v2’s output dimensions) and an HNSW index. Subsequent runs reuse the existing table; you only pay the embedding cost once unless you call add_documents again.

Persistent Chat Memory Implementation

from langchain_community.chat_message_histories import CassandraChatMessageHistory

def get_chat_history(session_id: str) -> CassandraChatMessageHistory:
return CassandraChatMessageHistory(
    		session_id=session_id,
    		table_name="chat_history",
	)

CassandraChatMessageHistory stores each message as a row keyed on session_id. Because rows are written to ScyllaDB, the history survives process crashes, server restarts, and horizontal scaling. Any replica that opens the same session_id sees the same history.

Change session_id to start a fresh conversation. Keep it the same to resume where you left off — that is the entire persistence mechanism.

Putting It Together

from langchain_groq import ChatGroq
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_core.runnables.history import RunnableWithMessageHistory

llm = ChatGroq(model="llama-3.3-70b-versatile")

ablePassthrough
from langchain_core.runnables.history import RunnableWithMessageHistory

llm = ChatGroq(model="llama-3.3-70b-versatile")

prompt = ChatPromptTemplate.from_messages([
	("system",
 	"You are a helpful assistant. Answer the user's question using the "
 	"retrieved context below.nnContext:n{context}"),
	MessagesPlaceholder(variable_name="chat_history"),
	("human", "{question}"),
])

chain = (
	RunnablePassthrough.assign(context=lambda x: "nn".join(
    	d.page_content for d in retriever.invoke(x["question"])
	))
	| prompt
	| llm
	| StrOutputParser()
)

chain_with_history = RunnableWithMessageHistory(
	chain,
	get_chat_history,
	input_messages_key="question",
	history_messages_key="chat_history",
)

config = {"configurable": {"session_id": "user-abc-session-1"}}

answer1 = chain_with_history.invoke(
	{"question": "What is the difference between a partition key and a clustering key in ScyllaDB?"},
	config=config,
)
print(answer1)

answer2 = chain_with_history.invoke(
	{"question": "How does using both keys affect the sort order of the data within a partition?"},
	config=config,
)
print(answer2)  # References the prior turn via memory

RunnableWithMessageHistorywraps the chain and automatically loads prior turns from get_chat_historybefore each call, then appends the new turn after. Both storage operations hit ScyllaDB.

The second question drills deeper into clustering columns introduced in the first answer. Without persistent memory, the LLM would have no context for what was already explained; with it, the conversation flows naturally across turns.

ScyllaDB Schema

rag_docs, the vector store:

CREATE TABLE demo.rag_docs (
	row_id      	text PRIMARY KEY,
	attributes_blob text,
	body_blob   	text,
	metadata_s  	map<text, text>,
	vector      	vector<float, 384>,
);

CREATE CUSTOM INDEX idx_vector_rag_docs ON demo.rag_docs (vector)
	USING 'vector_index';

CREATE INDEX eidx_metadata_s_rag_docs ON demo.rag_docs (ENTRIES(metadata_s));

chat_history, the message store:

CREATE TABLE demo.chat_history (
    partition_id  text,
    message_id    timeuuid,
    body_blob     text,
    PRIMARY KEY (partition_id, message_id)
) WITH CLUSTERING ORDER BY (message_id DESC);

Next Steps

The full demo code is available on GitHub. You can run it once to ingest and embed the articles, then run it again with the same SESSION_ID to verify that prior conversation turns are loaded from the database.

Resources:

Post on the ScyllaDB Forum if you have questions!

Uber has built an MCP Gateway to standardize how AI agents discover and invoke internal services, addressing fragmented integrations, duplicated infrastructure, and inconsistent security practices as agent adoption expands across the company. The platform supports more than 800 MCP servers and 5,000 tools, providing a common layer for discovery, protocol translation, authorization, and execution.

Uber engineers describe this approach as a microservice architecture that exposes existing APIs as MCP tools without requiring changes to the underlying services. The architecture separates the MCP Registry, which acts as the control plane, from the Proxy Gateway, which handles runtime execution. The registry maintains tool definitions, schemas, ownership, and enablement settings, while the proxy translates MCP requests into HTTP, gRPC, or TChannel calls and converts responses back into MCP-compatible results.

Uber MCP Gateway with APIs as tools (Source: Uber Blog Post)

The architecture has drawn comparisons with established API gateway patterns. Ajay Sharma, Principal Software Engineer at Microsoft CoreAI, wrote in a LinkedIn post,

Azure API Gateways has been doing this for a while now. It’s a recipe for order to the chaos that LLMs come with.

Kelly Goetsch, President at Pipe17, similarly observed in a LinkedIn post that

Uber’s new MCP gateway looks identical to gateways we’ve built over the decades for APIs and later GraphQL.

Tamir Dresher highlighted in a LinkedIn post the continuing relevance of established distributed systems concerns, including security, discovery, observability, and governance.

Uber’s AutoCrawler automates tool discovery using Cadence. It scans internal interface definition language (IDL) registries and extracts API definitions from Protocol Buffers and Thrift schemas. It then generates MCP-compatible schemas and uses a large language model to produce tool descriptions. Newly discovered tools remain disabled until their owning teams review and explicitly enable them. Configuration changes propagate to the data plane without requiring service restarts or redeployments.

Auto Crawler Flow (Source: Uber Blog Post)

The gateway enforces authorization at both server and tool levels through Uber’s internal access control system. It also supports redaction of personally identifiable information (PII) and other sensitive data in tool responses. For third-party integrations, including Jira and Google, a separate service exchanges internal user tokens for the corresponding third-party authentication tokens.

As the tool catalog grows, loading definitions for thousands of tools into an agent’s context becomes inefficient. Uber developed Omni MCP to support incremental discovery, allowing agents to search for servers, discover relevant tools, retrieve individual schemas, and invoke selected tools as needed. Response Projection lets agents request specific response fields instead of receiving complete payloads. Uber’s aifx command-line interface also enables coding agents to discover and invoke tools, writing results to files for selective inspection.