def generic_set_argv(*args):
    """
    Set the command line arguments passed to the script.

    Args:
    argv (list): The command line arguments to set.
    """
    parsed_args = {}
    for key in args:
        try:
            index = sys.argv.index(key)
            print(f"Index: {index}")
            if len(sys.argv) > index + 1 and not sys.argv[index + 1].startswith("-"):
                parsed_args[key] = sys.argv[index + 1]
            else:
                parsed_args[key] = True
        except ValueError:
            print(f"Error: {key} must be an integer.")
            parsed_args[key] = None
    logger.info(f"Command line arguments: {parsed_args}")
    return parsed_args

# Example how to use it 
# Parse command-line arguments
    arguments = generic_set_argv(
        '--version', '-v', '--help', '-h', '--howto',
        '--input_text', '-i', '--output', '-o',
        '--temperature', '-t', '--max_tokens',
        '--api_key', '-a', '--model', '-m',
        '--base-url', '-u'
    )

    # Handle specific commands
    if arguments.get('--models'):
        api_key = arguments.get('--api_key') or arguments.get('-a')
        if not api_key:
            logger.error("API Key is missing")
            return
        get_models_from_open_ai = get_available_models(api_key=api_key)
        if get_models_from_open_ai:
            logger.info("Available models from OpenAI:")
            pprint.pprint(get_models_from_open_ai)
            return

    # Display version information
    if arguments.get('--version') or arguments.get('-v'):
        print(f"{TOOL_NAME} version: {VERSION}")
        logger.info(f"{TOOL_NAME} version: {VERSION}")
        return

# First we have to set some setup to take arguments from CLI 
def generic_set_argv(*args):
    """
    Set the command line arguments passed to the script.

    Args:
    argv (list): The command line arguments to set.
    """
    parsed_args = {}
    for key in args:
        try:
            index = sys.argv.index(key)
            print(f"Index: {index}")
            if len(sys.argv) > index + 1 and not sys.argv[index + 1].startswith("-"):
                parsed_args[key] = sys.argv[index + 1]
            else:
                parsed_args[key] = True
        except ValueError:
            print(f"Error: {key} must be an integer.")
            parsed_args[key] = None
            #sys.exit(1)
    logger.info(f"Command line arguments: {parsed_args}")
    return parsed_args

def get_file_content(file_path):
    """
    Read the content of the provided file.

    Args:
    file_path (str): Path to the file.

    Returns:
    str: Content of the file as a string.
    """
    try:
        if file_path.endswith(".json"):
            logger.info(f"Reading context from JSON file: {file_path}")
            with open(file_path, "r") as f:
                json_content = json.load(f)
                return json.dumps(json_content, indent=4)  # Convert JSON to a formatted string
        else:
            logger.info(f"Reading context from text file: {file_path}")
            with open(file_path, "r") as f:
                return f.read()
    except Exception as e:
        logger.error(f"Error reading file {file_path} at line {e.__traceback__.tb_lineno}: {e}")
        return None

    Parameters:
    input_text (str): The input text to generate the completion.
    output_file (str): The output file to save the generated completion.
    temperature (str): The temperature for the completion.
    max_tokens (str): The maximum tokens for the completion.
    api_key (str): The OpenAI API key.
    model (str): The model for the completion.
    context (str): The context for the completion.

    Returns:
    str: The generated completion or None if an error occurs.
    """
    try:


        response = LangChainOpenAI(
            base_url=base_url,
            api_key=api_key,
            model=model if model else "llama-3.1-8b-instant",
            temperature=temperature if temperature else 0.5,
            max_tokens=max_tokens if max_tokens else 100,
            max_retries=2,
        )

  message = [
            (
                "system",
                f"You are a professional analyst who is working on a different and you will use {context} as context and then provide answer based on user question.",
            ),
            (
                "human", f"{input_text}"
            )
        ]

        answer = []
        print("\n")
        print(f"*" * 100)
        for chunk in response.stream(message):
            print(chunk.content, end="", flush=True)
            answer.append(chunk.content)
        print("\n")
        print(f"*" * 100)