Merge pull request #225 from oracle-samples/224-langchain-mcp

fix for import new optimizer_settings.json

Author: corradodebari

src/client/mcp/rag/README.md

@@ -39,7 +39,7 @@ In the **AI Optimizer & Toolkit** web interface, after tested a configuration, i
 There is a client that you can run without MCP via commandline to test it:
 
 ```bash
-uv run rag_base_optimizer_config.py   
+uv run rag_base_optimizer_config.py "[YOUR_QUESTION]"
 ```
 
 ## Quick test via MCP "inspector"
@@ -50,7 +50,14 @@ uv run rag_base_optimizer_config.py
 npx @modelcontextprotocol/inspector uv run rag_base_optimizer_config_mcp.py
 ```
 
-* connect to the port `http://localhost:6274/` with your browser
+* connect to the port `http://localhost:6274/` with your browser on the link printed, like in the following example:
+```bash
+..
+Open inspector with token pre-filled:
+http://localhost:6274/?MCP_PROXY_AUTH_TOKEN=cb2ef7521aaf2050ad9620bfb5e5df42dc958889e6e99ce4e9b18003eb93fffd
+..
+```
+
 * setup the `Inspector Proxy Address` with `http://127.0.0.1:6277` 
 * test the tool developed.
 

src/client/mcp/rag/optimizer_utils/config.py

@@ -1,3 +1,8 @@
+"""
+Copyright (c) 2024, 2025, Oracle and/or its affiliates.
+Licensed under the Universal Permissive License v1.0 as shown at http://oss.oracle.com/licenses/upl.
+"""
+
 from langchain_openai import ChatOpenAI
 from langchain_openai import OpenAIEmbeddings
 from langchain_huggingface import HuggingFaceEmbeddings
@@ -10,15 +15,19 @@
 from langchain_community.vectorstores.oraclevs import OracleVS
 import oracledb
 
+import logging
+logging.basicConfig(level=logging.INFO)
 
 def get_llm(data):
+    logging.info("llm data:")
+    logging.info(data["user_settings"]["ll_model"]["model"])
     llm={}
-    llm_config = data["ll_model_config"][data["client_settings"]["ll_model"]["model"]]
+    llm_config = data["ll_model_config"][data["user_settings"]["ll_model"]["model"]]
     api=llm_config["api"]
     url=llm_config["url"]
     api_key=llm_config["api_key"]
-    model=data["client_settings"]["ll_model"]["model"]
-    print(f"CHAT_MODEL: {model} {api} {url} {api_key}")
+    model=data["user_settings"]["ll_model"]["model"]
+    logging.info(f"CHAT_MODEL: {model} {api} {url} {api_key}")
     if api == "ChatOllama":
         # Initialize the LLM
         llm = OllamaLLM(
@@ -35,45 +44,45 @@ def get_llm(data):
 
 def get_embeddings(data):
     embeddings={}
-    model=data["client_settings"]["rag"]["model"]
+    model=data["user_settings"]["vector_search"]["model"]
     api=data["embed_model_config"][model]["api"]
     url=data["embed_model_config"][model]["url"]
     api_key=data["embed_model_config"][model]["api_key"]
-    print(f"EMBEDDINGS: {model} {api} {url} {api_key}")
+    logging.info(f"EMBEDDINGS: {model} {api} {url} {api_key}")
     embeddings = {}
     if  api=="OllamaEmbeddings":
          embeddings=OllamaEmbeddings(
             model=model,
             base_url=url)
     elif api == "OpenAIEmbeddings":
-         print("BEFORE create embbedding")
+         logging.info("BEFORE create embbedding")
          embeddings = OpenAIEmbeddings(
             model=model,
             api_key=api_key
          )   
-         print("AFTER create emebdding")
+         logging.info("AFTER create emebdding")
     return embeddings
 
 def get_vectorstore(data,embeddings):
 
-    config=data["database_config"][data["client_settings"]["rag"]["database"]]
-   
+    config=data["database_config"][data["user_settings"]["database"]["alias"]]
+    logging.info(config)
+
     conn23c = oracledb.connect(user=config["user"], 
                                password=config["password"], dsn=config["dsn"])
 
-    print("DB Connection successful!")
-    metric=data["client_settings"]["rag"]["distance_metric"]
+    logging.info("DB Connection successful!")
+    metric=data["user_settings"]["vector_search"]["distance_metric"]
 
     dist_strategy=DistanceStrategy.COSINE
     if metric=="COSINE":
         dist_strategy=DistanceStrategy.COSINE
     elif metric == "EUCLIDEAN":
         dist_strategy=DistanceStrategy.EUCLIDEAN
 
-    print("1")
-    a=data["client_settings"]["rag"]["vector_store"]
-    print(f"{a}")
-    print(f"BEFORE KNOWLEDGE BASE")
-    print(embeddings)
-    knowledge_base = OracleVS(conn23c, embeddings, data["client_settings"]["rag"]["vector_store"], dist_strategy)
-    return knowledge_base
+    a=data["user_settings"]["vector_search"]["vector_store"]
+    logging.info(f"{a}")
+    logging.info(f"BEFORE KNOWLEDGE BASE")
+    logging.info(embeddings)
+    knowledge_base = OracleVS(conn23c, embeddings, data["user_settings"]["vector_search"]["vector_store"], dist_strategy)
+    return knowledge_base

src/client/mcp/rag/optimizer_utils/rag.py

@@ -2,80 +2,81 @@
 Copyright (c) 2024, 2025, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v1.0 as shown at http://oss.oracle.com/licenses/upl.
 """
-
 from typing import List
 from mcp.server.fastmcp import FastMCP
 import os
 from dotenv import load_dotenv
-
-# from sentence_transformers import CrossEncoder
-# from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain_core.prompts import PromptTemplate
 from langchain_core.runnables import RunnablePassthrough
 from langchain_core.output_parsers import StrOutputParser
 import json
 import logging
-
 logging.basicConfig(level=logging.DEBUG)
 
 from optimizer_utils import config
 
-_optimizer_settings_path = ""
-
+_optimizer_settings_path= ""
 
 def set_optimizer_settings_path(path: str):
     global _optimizer_settings_path
     _optimizer_settings_path = path
 
-
 def rag_tool_base(question: str) -> str:
     """
     Use this tool to answer any question that may benefit from up-to-date or domain-specific information.
-
+    
     Args:
         question: the question for which are you looking for an answer
-
+        
     Returns:
         JSON string with answer
     """
     with open(_optimizer_settings_path, "r") as file:
         data = json.load(file)
-        try:
+        logging.info("Json loaded!")
+        try: 
+        
             embeddings = config.get_embeddings(data)
-
-            print("Embedding successful!")
-            knowledge_base = config.get_vectorstore(data, embeddings)
-            print("DB Connection successful!")
-
-            print("knowledge_base successful!")
+        
+            logging.info("Embedding successful!")
+            knowledge_base = config.get_vectorstore(data,embeddings)
+            logging.info("DB Connection successful!")
+    
+            logging.info("knowledge_base successful!")
             user_question = question
-            # result_chunks=knowledge_base.similarity_search(user_question, 5)
-
-            for d in data["prompt_configs"]:
-                if d["name"] == data["client_settings"]["prompts"]["sys"]:
-                    rag_prompt = d["prompt"]
-
-            template = """DOCUMENTS: {context} \n""" + rag_prompt + """\nQuestion: {question} """
-            # template = """Answer the question based only on the following context:{context} Question: {question} """
-            print(template)
+            logging.info("start looking for prompts")
+            for d in data["prompts_config"]:
+                if d["name"]==data["user_settings"]["prompts"]["sys"]:
+             
+                    rag_prompt=d["prompt"]
+            
+            logging.info("rag_prompt:")
+            logging.info(rag_prompt)
+            template = """DOCUMENTS: {context} \n"""+rag_prompt+"""\nQuestion: {question} """
+            logging.info(template)
             prompt = PromptTemplate.from_template(template)
-            print("before retriever")
-            print(data["client_settings"]["rag"]["top_k"])
-            retriever = knowledge_base.as_retriever(search_kwargs={"k": data["client_settings"]["rag"]["top_k"]})
-            print("after retriever")
+            logging.info("before retriever")
+            logging.info(data["user_settings"]["vector_search"]["top_k"])
+            retriever = knowledge_base.as_retriever(search_kwargs={"k": data["user_settings"]["vector_search"]["top_k"]})
+            logging.info("after retriever")
+        
 
             # Initialize the LLM
-            llm = config.get_llm(data)
-
-            chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser()
-            print("pre-chain successful!")
+            llm =  config.get_llm(data)
+
+            chain = (
+                {"context": retriever, "question": RunnablePassthrough()}
+                    | prompt
+                    | llm
+                    | StrOutputParser()
+            )
+            logging.info("pre-chain successful!")
             answer = chain.invoke(user_question)
 
-            # print(f"Results provided for question: {question}")
-            # print(f"{answer}")
+
         except Exception as e:
-            print(e)
-            print("Connection failed!")
-            answer = ""
+            logging.info(e)
+            logging.info("Connection failed!")
+            answer=""
 
     return f"{answer}"

src/client/mcp/rag/rag_base_optimizer_config.py

@@ -2,18 +2,16 @@
 Copyright (c) 2024, 2025, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v1.0 as shown at http://oss.oracle.com/licenses/upl.
 """
+import sys
 from typing import List
-#from mcp.server.fastmcp import FastMCP
 import os
 from dotenv import load_dotenv
-#from sentence_transformers import CrossEncoder
-#from langchain_community.embeddings import HuggingFaceEmbeddings
 import logging
 logging.basicConfig(level=logging.INFO)
 
 
 
-print("Successfully imported libraries and modules")
+logging.info("Successfully imported libraries and modules")
 
 from optimizer_utils import config
 
@@ -34,7 +32,7 @@ def similarity_search(question: str, max_results: int = 5) -> List[str]:
         List of information related to the question
     """
 
-    print(f"Results provided for question: {question} with top {max_results}")
+    logging.info(f"Results provided for question: {question} with top {max_results}")
     chunks=["first chunk", "second chunk"]
 
     return chunks
@@ -43,10 +41,13 @@ def similarity_search(question: str, max_results: int = 5) -> List[str]:
     # Initialize and run the server
     # Load JSON file
     file_path = os.path.join(os.getcwd(), "optimizer_settings.json")
-    print(file_path)
+    logging.info(file_path)
     rag.set_optimizer_settings_path(file_path)
-    
-    #Set your question to check if configuration is working
-    question="Which kind of IDE should be used in this demo?"
-    print(f"Question: {question}")
-    print(f"Answer: {rag.rag_tool_base(question)}")
+
+    if len(sys.argv) > 1:
+        question = sys.argv[1]
+        print(question)
+        logging.info(f"Question: {sys.argv[1]}")
+        logging.info(f"\n\nAnswer: {rag.rag_tool_base(question)}")
+    else:
+        logging.info("No question provided.")

src/client/mcp/rag/rag_base_optimizer_config_mcp.py

@@ -18,7 +18,7 @@
 from optimizer_utils import rag
 
 
-print("Successfully imported libraries and modules")
+logging.info("Successfully imported libraries and modules")
 
 CHUNKS_DIR = "chunks_temp"
 data = {}
@@ -62,8 +62,8 @@ def rag_tool(question: str) -> str:
 
     # Initialize and run the server
 
-    # Set optimizer_settings.json file absolute path
-    rag.set_optimizer_settings_path("/Users/cdebari/Documents/GitHub/ai-optimizer-mcp-export/src/client/mcp/rag/optimizer_settings.json")
+    # Set optimizer_settings.json file ABSOLUTE path
+    rag.set_optimizer_settings_path("optimizer_settings.json")
 
     mcp.run(transport='stdio')
     #mcp.run(transport='sse')