Steve Nyemba
4 weeks ago
parent
394b24fc7d
commit
1554087a08
|
After Width: | Height: | Size: 49 KiB |
@ -1,218 +1,214 @@
|
|||||||
"""
|
from langchain_ollama import ChatOllama
|
||||||
This is code that will interact with an LLM (AzureOpenAI/Ollama) leveraging langchain
|
from langchain_openai import AzureChatOpenAI, ChatOpenAI
|
||||||
"""
|
import requests
|
||||||
# _CATALOG = {
|
from typing import Optional
|
||||||
# 'sqlite':{'sql':'select tbl_name as table_name, json_group_array(y.name) as columns from sqlite_master x INNER JOIN PRAGMA_TABLE_INFO(tbl_name) y group by table_name'} ,
|
|
||||||
# 'postgresql':{'sql':"SELECT table_name, to_json(array_agg(column_name)) as columns FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = 'public' GROUP BY table_name"},
|
|
||||||
# 'bigquery':{'sql':'SELECT table_name, TO_JSON(ARRAY_AGG(column_name)) as columns FROM :dataset.INFORMATION_SCHEMA.COLUMNS','args':['dataset']},
|
|
||||||
# 'duckdb':{'sql' :'SELECT table_name, TO_JSON(ARRAY_AGG(column_name)) as columns FROM INFORMATION_SCHEMA.COLUMNS GROUP BY table_name'}
|
|
||||||
# }
|
|
||||||
|
|
||||||
# _CATALOG['sqlite3'] = _CATALOG['sqlite']
|
|
||||||
import transport
|
|
||||||
import json
|
import json
|
||||||
import os
|
from langchain_core.prompts import ChatPromptTemplate
|
||||||
|
from langchain_core.tools import StructuredTool
|
||||||
|
from langchain.agents import create_agent
|
||||||
|
from pydantic import create_model
|
||||||
|
|
||||||
|
from pydantic import BaseModel, Field, field_validator
|
||||||
|
|
||||||
|
from typing import Dict, Any, List
|
||||||
|
from langchain.agents.structured_output import ToolStrategy
|
||||||
|
import transport
|
||||||
import cms
|
import cms
|
||||||
import pandas as pd
|
import pandas as pd
|
||||||
from langchain_openai import AzureOpenAI, AzureChatOpenAI
|
import plugin_ix as plug
|
||||||
from langchain_ollama import OllamaEmbeddings, OllamaLLM
|
import os
|
||||||
from langchain_core.messages import HumanMessage, AIMessage
|
|
||||||
from langchain_classic.chains import LLMChain
|
_map ={
|
||||||
from langchain_core.prompts import PromptTemplate
|
'postgresql':"Select table_schema||'.'||table_name as table_name, table_schema as schema_name, column_name, data_type as type from information_schema.columns",
|
||||||
from langchain_core.runnables import RunnablePassthrough
|
'duckdb':"SELECT table_schema||'.'||table_name as table_name , table_schema AS schema_name, column_name, data_type FROM information_schema.columns",
|
||||||
from langchain_core.output_parsers import StrOutputParser
|
'sqlite3':'SELECT * FROM sqlite_master',
|
||||||
|
'mysql':'SELECT table_name, table_schema AS schema_name, column_name, data_type FROM information_schema.columns',
|
||||||
class Agent :
|
'bigquery':'SELECT table_name, table_schema AS schema_name, column_name, data_type FROM :dataset.INFORMATION_SCHEMA.COLUMNS',
|
||||||
def __init__(self,**_args) :
|
'iceberg':'SHOW TABLES', 'mariadb':'SHOW TABLES'
|
||||||
|
}
|
||||||
|
class AnalysisItem(BaseModel):
|
||||||
|
title: str = Field(description="Short title for this piece of analysis")
|
||||||
|
explanation: str = Field(description="Explanation of the insight")
|
||||||
|
# Using a structured dict or strict List[Dict]
|
||||||
|
data: List[Dict[str, Any]] = Field(description="Relevant rows supporting this analysis point")
|
||||||
|
|
||||||
|
@field_validator('data', mode='before')
|
||||||
|
@classmethod
|
||||||
|
def ensure_list_of_dicts(cls, v):
|
||||||
|
if isinstance(v, dict):
|
||||||
|
return [v] # Wrap single dicts if the LLM forgot the list wrapper
|
||||||
|
return v
|
||||||
|
|
||||||
|
class QueryOutput(BaseModel):
|
||||||
|
query: str = Field(description="The query that was generated and executed")
|
||||||
|
data: List[Dict[str, Any]] = Field(description="Rows returned from executing the query")
|
||||||
|
analysis: List[AnalysisItem] = Field(description="Analysis points derived from the data")
|
||||||
|
|
||||||
|
@field_validator('data', mode='before')
|
||||||
|
@classmethod
|
||||||
|
def ensure_list_of_dicts(cls, v):
|
||||||
|
if isinstance(v, dict):
|
||||||
|
return [v]
|
||||||
|
return v
|
||||||
|
|
||||||
|
class Tool:
|
||||||
|
def __init__(self,_dbr) :
|
||||||
|
self._dbr = _dbr
|
||||||
|
self._provider = _dbr._agent._engine.name
|
||||||
|
|
||||||
|
|
||||||
|
def catalog(self):
|
||||||
"""
|
"""
|
||||||
:backend OpenAI or Ollama
|
This function returns the catalog of the current database
|
||||||
:kwargs The initialization parameters associated with the backend
|
|
||||||
The arguments will contain temperature and model name to be used
|
|
||||||
"""
|
"""
|
||||||
_instance = AzureChatOpenAI if _args['backend'].lower() in ['azureopenai', 'openai'] else OllamaLLM
|
global _map
|
||||||
self._llm = _instance(**_args['kwargs'])
|
_query = _map.get(self._provider)
|
||||||
def isSQL(self,_question):
|
|
||||||
_template = """Is the provided text a valid sql statmement. Yes or No? Your answer is a properly formatted JSON object with three attributes.
|
|
||||||
class (1 for valid sql statement and 0 for not a valid sql statement), explanation place a short explanation for the answer and original containing with the original text.
|
|
||||||
|
|
||||||
text:
|
return self.read(_query)
|
||||||
{input_text}
|
def schema(self,table:str) ->dict:
|
||||||
"""
|
"""
|
||||||
_prompt = PromptTemplate(temperature=0.1,input_variables=['input_text'],template=_template)
|
This function returns the schema for a given database, if table is not provided the entire catalog will be returned with the list of tables
|
||||||
|
"""
|
||||||
r = self.apply(_prompt,input_text=_question)
|
_query = f""" {_map[self._provider]} WHERE name = '{table}' """
|
||||||
#
|
if self._provider in ['sqlite','sqlite3'] :
|
||||||
# @TODO: Make sure the response is properly formatted (output not to be trusted)
|
_info = self.read(f"select * from {table} limit 20").dtypes
|
||||||
return json.loads(r)
|
return pd.DataFrame({"column_name":_info.dtypes.index.tolist()[1:],"data_type": [x.name for x in _info.dtypes.tolist()[1:]]}).to_dict(orient='records')
|
||||||
def apply(self,_prompt,**_args):
|
pass
|
||||||
|
else:
|
||||||
chain = (
|
return self.read(_query)
|
||||||
RunnablePassthrough.assign()
|
def read(self,query:str)->dict:
|
||||||
| _prompt
|
"""
|
||||||
| self._llm
|
This function will execute a query against a given label/database. The query must adhere to the schema of the tables involved.
|
||||||
| StrOutputParser())
|
"""
|
||||||
_out = chain.invoke(_args)
|
return self._dbr.read(sql=query).to_dict(orient='records')
|
||||||
|
|
||||||
return _out #son.loads(_out)
|
|
||||||
def toSQL(self,_question,_catalog,_about):
|
|
||||||
_template="""Your task is to convert a question to an SQL query. The query will run on schema that will be provided in csv format.
|
|
||||||
|
|
||||||
Output:
|
|
||||||
The expected output will be a JSON object with two attributes sql and tables:
|
|
||||||
- "sql": the SQL query to be executed.
|
|
||||||
- "tables": list of relevant tables used.
|
|
||||||
|
|
||||||
Guidelines:
|
class TransportAgent:
|
||||||
- If the question can not be answered with the provided schema return empty string in the sql attribute
|
"""
|
||||||
- Parse the question word by word so as to be able to identify tables, fields and operations associated (Joins, filters ...)
|
This class is intended to allow an LLM to interact with data-transport MCP server.
|
||||||
- Under no circumstances will you provide an explanation of tables or reasoning detail.
|
"""
|
||||||
- Avoid using subqueries, and use field names as represented in the provided schema and their data types
|
def __init__(self, **kwargs):
|
||||||
|
"""
|
||||||
|
:backend ollama or openai (for now)
|
||||||
|
:kwargs parameters that will be used for the openai,ollama classes
|
||||||
|
"""
|
||||||
|
self.backend = kwargs.get('backend', 'ollama').lower()
|
||||||
|
self.kwargs = kwargs.get('kwargs', {}).copy()
|
||||||
|
# self.mcp_url = kwargs.get('mcp_url', 'http://localhost:8090')
|
||||||
|
self.chatbot = self.instance(self.backend, **self.kwargs)
|
||||||
|
# self.tools = self._init_mcp_tools()
|
||||||
|
# self.agent = self._init_agent()
|
||||||
|
registry = plug.Registry()
|
||||||
|
if registry.has(kwargs['parser']) :
|
||||||
|
self._parser = registry.get(kwargs['parser'])
|
||||||
|
else:
|
||||||
|
self._parser = None
|
||||||
|
|
||||||
question:
|
def instance(self, backend, **kwargs):
|
||||||
{question}
|
"""
|
||||||
|
Returns a chat model instance for the given backend.
|
||||||
|
Supported: ollama, azureopenai, openai.
|
||||||
|
"""
|
||||||
|
if backend == 'azureopenai':
|
||||||
|
return AzureChatOpenAI(**kwargs)
|
||||||
|
elif backend == 'openai':
|
||||||
|
return ChatOpenAI(**kwargs)
|
||||||
|
else:
|
||||||
|
return ChatOllama(**kwargs)
|
||||||
|
def get(self,label,query):
|
||||||
|
dbr = transport.get.reader(label=label)
|
||||||
|
tools = Tool(dbr)
|
||||||
|
# self.chatbot.bind_tools ([tools.catalog,tools.read])
|
||||||
|
|
||||||
Database schema:
|
_message = f"""
|
||||||
{catalog}
|
You are a specialized Data-Transport Agent designed to facilitate data access and analysis from registered
|
||||||
|
labels/databases. The user is working in {label} database ({dbr._agent._engine.name} database).
|
||||||
|
|
||||||
|
Your primary goal is to execute a requested operation based on the user's query. You MUST strictly adhere to
|
||||||
|
the following process and output format.
|
||||||
|
|
||||||
additional information:
|
**Process Flow:**
|
||||||
{context}
|
if and ONLY if the user's question is a database query execute the "read" function associated with the tools.
|
||||||
|
Otherwise perform the following:
|
||||||
|
1. **Catalog Retrieval:** First, return the list of tables with a field describing the table.
|
||||||
|
schema) from the catalog.
|
||||||
|
2. **Query Generation:** Construct an accurate SQL query that directly addresses the user's request using the
|
||||||
|
the information pulled from the catalog.
|
||||||
|
3. Make sure the generated query adheres to constraints of {dbr._agent._engine.name} database
|
||||||
|
4. **Execution:** Execute the SQL query against by calling the "read" function of the tools.
|
||||||
|
5. **Analysis is Optional and should be provided ONLY if the user requested it:** If the user asks for an analysis, perform the necessary data processing and derive
|
||||||
|
meaningful insights based on the query data.
|
||||||
|
|
||||||
|
**Output Format Enforcement:**
|
||||||
|
You MUST respond ONLY with a single JSON object. Do not include any introductory text, explanations, or
|
||||||
|
conversational language outside of the JSON structure.
|
||||||
|
|
||||||
|
**JSON Schema Requirements:**
|
||||||
|
The output MUST strictly conform to the following JSON structure, utilizing the `QueryOutput` schema defined by
|
||||||
|
your execution context:
|
||||||
|
- **"query"**: The exact SQL query that was executed.
|
||||||
|
- **"data"**: A list of dictionaries containing the raw data rows returned from the query execution.
|
||||||
|
- **"analysis"**: An optional list of analysis points. If analysis was performed, this list MUST contain
|
||||||
|
objects with the following structure:
|
||||||
|
- "title": A concise title for the derived insight. It can ONLY be 30 characters at most.
|
||||||
|
- "data": The specific data rows supporting the analysis.
|
||||||
|
- "text": A detailed explanation of the insight derived from the data.
|
||||||
|
|
||||||
|
Ensure all generated data and analysis are directly traceable back to the executed query and the retrieved
|
||||||
|
table schemas.
|
||||||
"""
|
"""
|
||||||
|
_caller = create_agent(self.chatbot,[tools.catalog,tools.schema,tools.read],system_prompt=_message,response_format=QueryOutput)
|
||||||
_prompt = PromptTemplate(temperature=0.1,input_variables=['question','catalog','context'],template=_template)
|
_output = _caller.invoke({"messages":[("user",query)]})["messages"][-1].content
|
||||||
r = self.apply(_prompt,question=_question,catalog=_catalog,context=_about)
|
if self._parser :
|
||||||
# print (' ############### ------------- #####################')
|
return self._parser(_output)
|
||||||
# print (r)
|
else:
|
||||||
# print (' #########################################')
|
return _output
|
||||||
#
|
LLM_ARGS = {}
|
||||||
# @TODO: Make sure the response is properly formatted (output not to be trusted)
|
def InitLLMArgs (_config):
|
||||||
if '```json' in r :
|
global LLM_ARGS
|
||||||
r = r.split('```json')[-1].replace('```','')
|
|
||||||
print (r)
|
|
||||||
return json.loads(r)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#
|
|
||||||
# We are building an interface to execute an sql query
|
|
||||||
#
|
|
||||||
|
|
||||||
def AIProxy (_label,_query,_path,_CATALOG) :
|
|
||||||
_qreader = transport.get.reader(label=_label)
|
|
||||||
_entry = transport.registry.get(_label)
|
|
||||||
_provider =_entry['provider']
|
|
||||||
_about = _entry.get('about','')
|
|
||||||
_database = _entry['database'] if 'database' in _entry else ''
|
|
||||||
|
|
||||||
if 'dataset' in _entry :
|
|
||||||
_database = _entry['dataset']
|
|
||||||
_about = f'{_about}, with dataset name {_database}'
|
|
||||||
else:
|
|
||||||
_about = f'{_about}, with the database name {_database}'
|
|
||||||
_catalog = None
|
|
||||||
_kwargs = None
|
|
||||||
_data = pd.DataFrame()
|
|
||||||
r = None
|
|
||||||
try:
|
|
||||||
#
|
|
||||||
# we should run the command here, assuming a valid query
|
|
||||||
#
|
|
||||||
|
|
||||||
_data = _qreader.apply(_query)
|
|
||||||
except Exception as e:
|
|
||||||
#
|
|
||||||
# here we are assuming we are running text to be translated as a query
|
|
||||||
# we need to make sure that we have a JSON configurator
|
|
||||||
#
|
|
||||||
if _provider in _CATALOG and os.path.exists(_path):
|
|
||||||
#
|
|
||||||
# -- reading arguments from the LLM config file, {backend,kwargs}
|
|
||||||
_kwargs = json.loads((open(_path)).read())
|
|
||||||
_agent = Agent(**_kwargs)
|
|
||||||
_qcat = _CATALOG[_provider]
|
|
||||||
if 'args' in _CATALOG[_provider] :
|
|
||||||
_entry = transport.registry.get(_label)
|
|
||||||
for _var in _CATALOG[_provider]['args'] :
|
|
||||||
if _var in _entry:
|
|
||||||
_value = _entry[_var]
|
|
||||||
_about = f'{_about}\n{_var} = {_value}'
|
|
||||||
_qcat['sql'] = _qcat['sql'].replace(f':{_var}',_value)
|
|
||||||
|
|
||||||
_catalog = _qreader.read(**_qcat).to_csv(index=0)
|
|
||||||
_about = f"The queries will run on {_provider} database.\n{_about}"
|
|
||||||
r = _agent.toSQL(_query,_catalog, _about)
|
|
||||||
|
|
||||||
try:
|
|
||||||
_data = _qreader.apply(r['sql'])
|
|
||||||
except Exception as e1:
|
|
||||||
_data = pd.DataFrame()
|
|
||||||
pass
|
|
||||||
#
|
|
||||||
# returning the data and the information needed
|
|
||||||
#
|
|
||||||
_data = _data.astype(str).to_dict(orient='split')
|
|
||||||
del _data['index']
|
|
||||||
if r :
|
|
||||||
return {'data':_data,'query':r['sql']}
|
|
||||||
return _data
|
|
||||||
|
|
||||||
|
|
||||||
# if not _path :
|
path = _config['system']['source']['ai']['config-path']
|
||||||
# #
|
f = open(path)
|
||||||
# # exececute the query as is !
|
LLM_ARGS = json.loads(f.read())
|
||||||
# pass
|
f.close()
|
||||||
# else:
|
#
|
||||||
|
# We also have to initialize the plugin path
|
||||||
# if _provider in _CATALOG and os.path.exists(_path) :
|
os.environ['REGISTRY_FOLDER'] = _config['system']['source']['ai']['plugin-path']
|
||||||
|
return LLM_ARGS
|
||||||
# #
|
|
||||||
# # As the agent if it is an SQL Query
|
|
||||||
# f = open(_path)
|
|
||||||
# _kwargs = json.loads( f.read() )
|
|
||||||
# f.close()
|
|
||||||
# try:
|
|
||||||
|
|
||||||
# print ([f"Running Model {_kwargs['kwargs']['model']}"])
|
|
||||||
# _agent = Agent(**_kwargs)
|
|
||||||
# # r = _agent.isSQL(_query)
|
|
||||||
|
|
||||||
# # print (f"****** {_query}\n{r['class']}")
|
|
||||||
# # if r and int(r['class']) == 0 :
|
|
||||||
# _catalog = _qreader.read(**_CATALOG[_provider]).to_csv(index=0)
|
|
||||||
# # print (['****** TABLES FOUND ', _catalog])
|
|
||||||
# _about = _about if _about else ''
|
|
||||||
# r = _agent.toSQL(_query,_catalog,f"This is a {_provider} database, and queries generated should account for this. {_about}")
|
|
||||||
# _query = r['sql']
|
|
||||||
# # else:
|
|
||||||
# # #
|
|
||||||
# # # provided an sql query
|
|
||||||
# # pass
|
|
||||||
# except Exception as e:
|
|
||||||
# #
|
|
||||||
# # AI Service is unavailable ... need to report this somehow
|
|
||||||
# print (e)
|
|
||||||
# else:
|
|
||||||
# #
|
|
||||||
# # Not in catalog ...
|
|
||||||
# pass
|
|
||||||
# _data = _qreader.apply(_query)
|
|
||||||
# if _data.shape[0] :
|
|
||||||
# _data = _data.astype(str).to_dict(orient='split')
|
|
||||||
# if 'index' in _data :
|
|
||||||
# del _data['index']
|
|
||||||
# return _data
|
|
||||||
|
|
||||||
|
|
||||||
@cms.Plugin(mimetype="application/json",method="POST")
|
@cms.Plugin(mimetype="application/json",method="POST")
|
||||||
def apply (**_args):
|
def apply(**_args):
|
||||||
|
global LLM_ARGS
|
||||||
_request = _args['request']
|
_request = _args['request']
|
||||||
|
_config = _args['config']
|
||||||
|
#
|
||||||
|
# let's make sure the _label is whitelisted
|
||||||
_label = _request.json['label']
|
_label = _request.json['label']
|
||||||
_query = _request.json['query']
|
_query = _request.json['query']
|
||||||
_source = _args['config']['system']['source']
|
if not LLM_ARGS :
|
||||||
_path = _source.get('llm',None)
|
LLM_ARGS = InitLLMArgs(_args['config'])
|
||||||
_CATALOGS = _source.get('catalogs',{})
|
if _query.strip().lower().startswith("with") or _query.strip().lower().startswith("select") :
|
||||||
return AIProxy(_label,_query,_path,_CATALOGS)
|
dbr = transport.get.reader(label=_label)
|
||||||
|
|
||||||
|
return { "data":dbr.read(sql=_query).fillna(0).to_dict(orient='records') ,"analysis":[]}
|
||||||
|
elif _query.strip().lower().startswith("{") :
|
||||||
|
dbr = transport.get.reader(label=_label)
|
||||||
|
return { "data":dbr.read(json.loads(_query)).to_dict(orient='records'),"analysis":[] }
|
||||||
|
|
||||||
|
_agent = TransportAgent(**LLM_ARGS)
|
||||||
|
|
||||||
|
# we need an output parser for the models (should be loaded as a plugin)
|
||||||
|
print ([LLM_ARGS['backend'], LLM_ARGS['kwargs']['model']])
|
||||||
|
return _agent.get(_label,_query)
|
||||||
|
|
||||||
|
# _data = {"query": "SELECT condition_concept_id, COUNT(*) AS condition_count FROM tabular.condition_occurrence GROUP BY condition_concept_id ORDER BY condition_count DESC LIMIT 10;", "data": [{"condition_concept_id": "316866", "condition_count": 5635}, {"condition_concept_id": "4159131", "condition_count": 5462}, {"condition_concept_id": "2005200547", "condition_count": 5375}, {"condition_concept_id": "4291025", "condition_count": 5037}, {"condition_concept_id": "201826", "condition_count": 4026}, {"condition_concept_id": "433736", "condition_count": 4011}, {"condition_concept_id": "4036620", "condition_count": 3734}, {"condition_concept_id": "4317977", "condition_count": 3341}, {"condition_concept_id": "37018196", "condition_count": 2627}, {"condition_concept_id": "81902", "condition_count": 2458}], "analysis": [{"title": "Top 10 Most Frequent Conditions", "data": [{"condition_concept_id": "316866", "condition_count": 5635}, {"condition_concept_id": "4159131", "condition_count": 5462}, {"condition_concept_id": "2005200547", "condition_count": 5375}, {"condition_concept_id": "4291025", "condition_count": 5037}, {"condition_concept_id": "201826", "condition_count": 4026}, {"condition_concept_id": "433736", "condition_count": 4011}, {"condition_concept_id": "4036620", "condition_count": 3734}, {"condition_concept_id": "4317977", "condition_count": 3341}, {"condition_concept_id": "37018196", "condition_count": 2627}, {"condition_concept_id": "81902", "condition_count": 2458}], "text": "The distribution analysis of conditions, based on the top 10 most frequent condition concept IDs, shows that '316866' is the most commonly recorded condition, with 5,635 occurrences. The top four conditions (316866, 4159131, 2005200547, and 4291025) account for a significant portion of the recorded conditions, indicating these are the most prevalent diagnoses in the dataset."}]}
|
||||||
|
# _data['data'] = pd.DataFrame(_data['data']).to_dict(orient='split',index=False)
|
||||||
|
# for _row in _data['analysis'] :
|
||||||
|
# if 'data' in _row :
|
||||||
|
# _row['data'] = pd.DataFrame(_row['data']).to_dict(orient='records')
|
||||||
|
# return _data
|
||||||
|
|
||||||
|
|
||||||
@cms.Plugin(mimetype="text/plain")
|
@cms.Plugin(mimetype="text/plain")
|
||||||
def enabled(**_args):
|
def enabled(**_args):
|
||||||
_config = _args['config']
|
_config = _args['config']
|
||||||
return str(int('llm' in _config['system']['source'] ))
|
return str(int('ai' in _config['system']['source'] ))
|
||||||
|
|||||||
@ -0,0 +1,42 @@
|
|||||||
|
# Transport Agent Notebook
|
||||||
|
|
||||||
|
This notebook provides a way to interact with the **data-transport MCP server** using LangChain and Marimo.
|
||||||
|
|
||||||
|
## Overview
|
||||||
|
|
||||||
|
The `notebook.py` file implements a `TransportAgent` class that bridges the gap between Large Language Models (LLMs) and the capabilities of the data-transport system via the **Model Context Protocol (MCP)**. It also demonstrates how to perform direct data access using the `transport` library.
|
||||||
|
|
||||||
|
## How it Works
|
||||||
|
|
||||||
|
The `notebook.py` file demonstrates how to integrate MCP with LangChain through the following steps:
|
||||||
|
|
||||||
|
1. **Dynamic Tool Discovery**: Instead of hard-coding tool definitions, the `TransportAgent` fetches the OpenAPI specification from the MCP server (at `http://localhost:8090/openapi.json`).
|
||||||
|
2. **Schema Mapping**: It automatically parses the OpenAPI `components` and `paths` to generate LangChain `StructuredTool` instances. This ensures that the agent always has the latest tools available as defined by the MCP server.
|
||||||
|
3. **Agent Construction**: These tools are then passed into a LangChain agent. The agent uses these tools to fulfill user requests, such as listing databases or performing data analysis.
|
||||||
|
4. **Interactive Interface**: The Marimo framework is used to provide a clean, interactive UI where users can type questions and see the agent's thought process and results.
|
||||||
|
|
||||||
|
## Code Breakdown
|
||||||
|
|
||||||
|
### `TransportAgent` Class
|
||||||
|
The heart of the notebook. It manages:
|
||||||
|
- **LLM Configuration**: Supports `ollama`, `openai`, and `azure_openai` backends.
|
||||||
|
- **Tool Initialization (`_init_mcp_tools`)**:
|
||||||
|
- Fetches the `openapi.json` from the local MCP server.
|
||||||
|
- Maps API types (string, integer, etc.) to Python types.
|
||||||
|
- Dynamically creates `StructuredTool` objects with proper descriptions and argument schemas.
|
||||||
|
- **Agent Initialization (`_init_agent`)**: Combines the chosen LLM with the discovered tools into a functional agent.
|
||||||
|
- **Query Handling (`get`)**: Takes a natural language prompt and returns the final response from the agent's execution chain.
|
||||||
|
|
||||||
|
## How to leverage MCP with LangChain (Summary)
|
||||||
|
|
||||||
|
To integrate MCP with LangChain in this project:
|
||||||
|
1. **Expose via OpenAPI**: The MCP server must provide an `openapi.json` endpoint.
|
||||||
|
2. **Automate Tool Creation**: Use a helper function (like `_init_mcp_tools` in this notebook) to iterate over the OpenAPI paths and generate `StructuredTool` objects.
|
||||||
|
3. **Bind to Agent**: Pass the list of generated tools to a LangChain agent (e.g., `create_agent`).
|
||||||
|
4. **Dynamic Updates**: Because the tools are loaded at runtime from the OpenAPI spec, any update to the MCP server's capabilities is automatically reflected in the agent.
|
||||||
|
|
||||||
|
## Usage
|
||||||
|
To run this notebook, ensure the MCP server is running on `localhost:8090` and then execute the marimo notebook:
|
||||||
|
```bash
|
||||||
|
marimo edit www/html/_plugins/notebook.py
|
||||||
|
```
|
||||||
Loading…
Reference in new issue