Below is an example of a chain‐of‐thought (CoT) system that uses internal tools to make decisions and then applies a series of prompts and reasoning steps. This implementation is inspired by real-world examples (see github.com, datacamp.com, and others), but note that the internal chain‐of‐thought is hidden from users.

Below is a Python code sample illustrating the process:

python
import json
import os
from duckduckgo_search import DDGS
from openai import OpenAI, APIConnectionError, APIError

# A tool function to perform web searches
def web_search(query):
    """Perform a DuckDuckGo web search for the given query."""
    try:
        with DDGS() as ddgs:
            results = [r for r in ddgs.text(query, max_results=5)]
            if results:
                return "\n".join([f"{i+1}. [{r['title']}]({r['href']})" for i, r in enumerate(results)])
            else:
                return "No results found."
    except Exception as e:
        return f"Search error: {e}"

# Tools configuration that may be used by the CoT process
tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Searches for information on the web.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search terms"}
                },
                "required": ["query"]
            }
        }
    }
]

# Configuration for the API connection (replace with your own API key and URL)
client_config = {
    "base_url": "https://api.yourllmprovider.ai/v1/",
    "api_key": os.getenv("API_KEY"),
    "model": "your-llm-model"
}

# Create an API client instance
client = OpenAI(
    base_url=client_config["base_url"],
    api_key=client_config["api_key"]
)

def test_api_connection():
    """Minimal test to check API connectivity."""
    try:
        response = client.chat.completions.create(
            model=client_config["model"],
            messages=[{"role": "user", "content": "Test connection"}]
        )
        print("Connection successful! Test response:")
        print(response.choices[0].message.content)
        return True
    except (APIConnectionError, APIError) as e:
        print(f"Connection error: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")
    return False

def main_loop():
    """
    Main loop for a CoT process that:
      1. Accepts a user question.
      2. Uses internal chain-of-thought reasoning to decide if a tool (web_search) should be used.
      3. If needed, calls the tool and appends the result to the conversation.
      4. Provides a final answer based on hidden internal reasoning.
      
    Note: The internal reasoning is not exposed.
    """
    messages = [
        {"role": "system", "content": (
            "You are an intelligent assistant that reasons step by step before giving a final answer. "
            "Use tools if necessary, but do not reveal your internal chain of thought."
        )}
    ]

    print("Enter your question (or type 'exit' to quit):")
    while True:
        question = input("\n==> ").strip()
        if question.lower() in ["exit", "quit"]:
            break

        messages.append({"role": "user", "content": question})

        try:
            # Call the API with tools enabled; the assistant internally decides on tool usage.
            response = client.chat.completions.create(
                model=client_config["model"],
                messages=messages,
                tools=tools,
                tool_choice="auto"  # The model automatically selects a tool if needed.
            )
            response_message = response.choices[0].message
            # Display the hidden chain-of-thought internally (only for developer logging)
            print("\n[REASONING (hidden)]")
            print(response_message.content or "No explicit reasoning provided.")
            # Process any tool calls made by the model.
            if response_message.tool_calls:
                for tool_call in response_message.tool_calls:
                    if tool_call.function.name == "web_search":
                        args = json.loads(tool_call.function.arguments)
                        print(f"\n[TOOL CALL] Searching for: {args['query']}")
                        tool_result = web_search(args["query"])
                        print(f"[TOOL RESULT]\n{tool_result[:500]}...")
                        messages.append({
                            "role": "tool",
                            "content": tool_result,
                            "tool_call_id": tool_call.id
                        })
            # Display final answer
            print("\n[FINAL ANSWER]")
            print(response_message.content)
        except (APIConnectionError, APIError) as e:
            print(f"API error: {e}")
        except Exception as e:
            print(f"Error: {e}")

        messages.append({"role": "assistant", "content": response_message.content})

if __name__ == "__main__":
    print("Testing API connection...")
    if test_api_connection():
        main_loop()

Explanation

1. Initialization & Tool Setup:
   The code defines a web_search function as a tool. A list of tools is passed along with the API request, letting the assistant call the tool automatically if its hidden internal chain-of-thought deems it necessary.

2. Internal Reasoning:
   The system message instructs the model to think step by step internally (chain-of-thought) without revealing the details. The internal reasoning is used to determine whether to call the tool and to ultimately provide the final answer.

3. Tool Integration:
   If the model makes a tool call, the web_search function is executed, and its result is appended to the conversation context. This aids in answering questions that require external information.

4. Hidden Chain-of-Thought:
   The actual chain-of-thought (CoT) is computed internally and only logged if needed for debugging. The assistant’s final output does not reveal this internal reasoning.

Final Note

This code provides a framework for integrating chain-of-thought reasoning with tool usage. Remember, the internal chain-of-thought remains hidden, ensuring that users see only the final answer. The assistant decides whether or not to use tools automatically, based on the hidden reasoning process.

Feel free to adapt and expand this framework to suit your specific application needs.

This is a complete example; if you have further questions or need additional modifications, let me know!