ollama-think


Nameollama-think JSON
Version 0.1.4 PyPI version JSON
download
home_pageNone
SummaryA light wrapper around ollama-python that introduces caching, syntax sugar and increased `think` compatibility
upload_time2025-07-09 08:26:53
maintainerNone
docs_urlNone
authorNone
requires_python>=3.9
licenseNone
keywords ai llm cogito compatibility granite ollama phi4-mini-reasoning phi4-reasoning think
VCS
bugtrack_url
requirements annotated-types anyio certifi click colorama coverage diskcache h11 httpcore httpx idna iniconfig markdown-it-py mdurl ollama packaging pluggy pydantic pydantic-core pygments pytest pytest-cov pytest-mock pyyaml rich ruff shellingham sniffio typer typing-extensions typing-inspection
Travis-CI No Travis.
coveralls test coverage No coveralls.
            # Ollama-Think Library

A thin wrapper around the [ollama-python](https://github.com/ollama/ollama-python) library with the addition of caching, increased `think` model compatibility and a little syntax sugar.


## Features

- **Caching**: Automatically caches responses to significantly speed up repeated requests.
- **Thinking**: Enables some officially unsupported models to use thinking mode. [Why hack?](why_hack.md)
- **Streaming and Non-streaming**: Separates the underlying streaming and non-streaming interface to provide clean type hints.
- **Syntax Sugar**: Less boiler-plate, so that you can maintain your flow.

## Quickstart

Get up and running in less than a minute.

**1. Install the library:**

```bash
pip install ollama-think
```

**2. Use:**

```python
from ollama_think import Client

# Initialize the client
client = Client(host="http://localhost:11434", cache_dir=".ollama_cache", clear_cache=False)

# unpack the response into thinking and content
thinking, content = client.call(
    model="qwen3",                 # or any other model
    prompt="Why is the sky blue?", # shortcut for messages=[{'role': 'user', 'content': 'Why is the sky blue?'}]
    think=True                     # Set to True to see the model's thinking process
)

print(f"Thinking: {thinking}, Content: {content}")
```

## Detailed Usage


### Non-streaming

The `call` method provides strongly typed access to the underlying `Chat` method in non-streaming mode. It returns a `ThinkResponse` object which is a subclass of `ollama.ChatResponse` and adds some convenience properties. You can use `prompt` or `messages` as you prefer.

```python
from ollama_think import Client
client = Client()

# Make a non-streaming call
response: ThinkResponse = client.call(
    model="qwen3",         # The model to use
    prompt="Hello, world!" # A single user message
    messages = None,       # or a list of messages
    tools = None,          # A list of tools available
    think = True,          # Enable thinking mode
    format = None,         # The format to return a response in: None | 'json' | your_obj.model_json_schema()
    options = None,        # Additional model parameter dict, such as {'temperature': 0.1, 'num_ctx': 8192}
    keep_alive = None,     # Controls how long the model will stay loaded in memory following the request.
    use_cache = True)      # If True, attempts to retrieve the response from cache.

# The response object contains all the original data from the Ollama ChatResponse
print(response)
# ThinkResponse(
#     model='qwen3',
#     created_at='2025-07-03T14:16:05.8452406Z',
#     done=True,
#     done_reason='stop',
#     total_duration=2461619200,
#     load_duration=2111438400,
#     prompt_eval_count=20,
#     prompt_eval_duration=78409600,
#     eval_count=16,
#     eval_duration=271104600,
#     message=Message(role='assistant', content='Hello, world! How can I assist you today?', thinking='...',
#                     images=None, tool_calls=None))

# For convenience, you can access the content and thinking as properties
print(response.thinking)
# '...'
print(response.content)
# 'Hello, world! ...'

# The response object can be used as a string which will show just the 'content'
print(f"The model said: {response}")  # same as response.content
# The model said: Hello, world! ...

# or unpack the response into thinking and content for single line access
thinking, content = response
print(f"Thinking: {thinking}, Content: {content}")
```

### Streaming

The `stream` method provides a strongly typed access to the underlying `Chat` method in streaming mode. It returns a an iterator of `ThinkResponse` chunks

```python
from ollama_think import Client
client = Client()

stream = client.stream(model="qwen3", prompt="Tell me a short story about italian chimpanzees and bananas", think=True)
for thinking, content in stream:
    print(thinking, end="")
    print(content, end="")  # empty until thinking is finished for most models
```

### Thinking Mode

The `think` parameter tells ollama to enable thinking for models that support this. For other models that use non-standard ways of enabling thinking we do the neccesary. [Why hack?](why_hack.md) Default config: [src/ollama_think/config.yaml](src/ollama_think/config.yaml) Results: [model_capabilities.md](model_capabilities.md)

Some models will think, even without 'enabling' thinking. This output is separated out of the `content` into `thinking`

Note: Not all models officially or unofficially support thinking. They will throw a `400` error if you try to enable thinking.


### Caching

The client automatically caches responses using the light-weight `DiskCache` library to avoid re-generating them for the same request. You can disable this behavior by setting `use_cache=False`.

```python
# This call will be cached
response1 = client.call(model="qwen3", prompt="Hello, world!") # 0.31 seconds

# This call will use the cached response
response2 = client.call(model="qwen3", prompt="Hello, world!") # 0.0001 seconds

# This call will not attempt to get from the cache and will not store the result
response3 = client.call(model="qwen3", prompt="Hello, world!", use_cache=False)
```

You can clear the cache by passing `clear_cache=True` when initializing the client:

```python
client = Client(clear_cache=True)
```

### Options

The `options` parameter of the underlying `chat` method can be used to change how the model
responds. The most commonly used parameters are

- `temperature` Low values keep the model deterministic, Higher values for more creativity Typically 0.1 -> 1.0
- `num_ctx` Ollama has a default context length of 2048, which can be increased if you have enough VRAM. If you send in more
than `num_ctx` tokens, ollama will silently truncate your message, which can lead to lost instructions.

```python
from ollama_think import Client
client = Client()

prompt="Describe the earth to an alien who has just arrived."
options={'num_ctx': 8192, 'temperature': 0.9}

print("Using prompt:", prompt)
print("Using options:", options)

thinking, content = client.call(model="qwen3", prompt=prompt, think=True, options=options)
print(f"Thinking: {thinking}, Content: {content}")
```

See [examples/options_example.py](examples/options_example.py) for a full list of options

### Tool Calling

Before, and underneath the concept of MCP servers are the humble tool_calls. By telling the model that you have a tool available,
the model can choose to reply with a special format that indicates that it wants to call a tool. Typically, this call is
intercepted, the tool is excecuted and the result sent back to the model. The model's second response can then be shown to a user.

See [examples/tool_calling_example.py](examples/tool_calling_example.py)

### Response Formats

Forcing JSON format can encourage some models to behave. It is usualy a good idea to mention JSON in the prompt.

```python
from ollama_think import Client
import json

client = Client()

text_json = client.call(
    model="qwen3",
    prompt="Design a json representation of a spiral galaxy",
    format="json",
).content

my_object = json.loads(text_json)  # might explode if invalid json was returned
```

You can use pydantic models to describe more exactly the format you want.

```python
from ollama_think import Client
from pydantic import BaseModel, Field
client = Client()

class Heat(BaseModel):
    """A specially crafted response object to capture an iterpretation of heat"""
    reaoning: str = Field(..., description="your reasoning for the response")
    average_temperature: float = Field(..., description="average temperature")

text_obj = client.call(model="qwen3", prompt="How hot is the world?",
        format=Heat.model_json_schema()).content

my_obj = Heat.model_validate_json(text_obj) # might explode it the format is invalid
```

See [examples/response_format_example.py](examples/response_format_example.py)

### Access to the underlying ollama client

Since the `ollama_think` is a thin wrapper around the `ollama.client`, you can still access the all the underlying ollama client methods.

```python
from ollama_think import Client
from ollama import ChatResponse

client = Client()
response: ChatResponse = client.chat(model='llama3.2', messages=[
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
])
print(response['message']['content'])
```

### Prompts and Messages

```python
from ollama_think import Client

client = Client()
# the prompt parameter in `call` and `stream` is just a shortcut for
prompt = 'Why is the sky blue?'
message =  {'role': 'user', 'content': prompt}
client.call(model='llama3.2', messages=[message])  # shortcut
client.call(model='llama3.2', prompt=prompt)       # same thing
```

## Credit to

- ollama [https://ollama.com/](https://ollama.com/)
- ollama-python [https://github.com/ollama/ollama-python](https://github.com/ollama/ollama-python)
- diskcache [https://github.com/grantjenks/python-diskcache/](https://github.com/grantjenks/python-diskcache/)
- pydantic [https://pydantic-docs.helpmanual.io/](https://pydantic-docs.helpmanual.io/)

## Reference docs

- Ollama Thinking - [https://ollama.com/blog/thinking](https://ollama.com/blog/thinking)
- Ollama Tool support - [https://ollama.com/blog/tool-support](https://ollama.com/blog/tool-support)
- Ollama Structured Outputs - [https://ollama.com/blog/structured-outputs](https://ollama.com/blog/structured-outputs)
- Ollama Options - [https://github.com/ollama/ollama-python/blob/main/ollama/_types.py](https://github.com/ollama/ollama-python/blob/main/ollama/_types.py)

## Contributing

Contributions are welcome! Please open an issue or submit a pull request.

### Development Setup

This project uses `uv` for package management and `hatch` for task running.

1.  **Clone the repository:**
    ```bash
    git clone https://github.com/your-username/ollama-think.git
    cd ollama-think
    ```

2.  **Create a virtual environment and install dependencies:**
    This command creates a virtual environment in `.venv` and installs all dependencies, including development tools.
    ```bash
    uv sync --extra dev
    ```

### Running Checks

- **Linting and Formatting:**
  To automatically format and lint the code, run:
  ```bash
  uv run ruff format .
  uv run ruff check . --fix
  ```

- **Running Tests:**
  - To run the default (fast) unit tests:
    ```bash
    uv run hatch test
    # or more simply
    uv run pytest
    ```
  - To run the full test suite, including `slow` integration tests that require a running Ollama instance:
    ```bash
    uv run hatch test:run -m "slow or not slow"
    ```
  - To pass a custom host to the integration tests:
    ```bash
    uv run hatch test:run -m "slow or not slow" --host http://localhost:11434
    ```


- **Testing new models:**

  ```python
  # edit /src/ollama_think/config.yaml
  # check the output from non-streaming and streaming
  uv run ./tests/test_hacks.py --host http://localhost:11434 --model "model_name"

  # check that this makes a difference
  uv run pytest ./tests/test_model_capabilities.py --host http://localhost:11434 -m "slow" --model "model_name"

  # re-generate doc
  uv run tests/generate_model_capabilities_report.py

  # submit a PR
  ```
 
## License

This project is licensed under the MIT License.

            

Raw data

            {
    "_id": null,
    "home_page": null,
    "name": "ollama-think",
    "maintainer": null,
    "docs_url": null,
    "requires_python": ">=3.9",
    "maintainer_email": null,
    "keywords": "AI, LLM, cogito, compatibility, granite, ollama, phi4-mini-reasoning, phi4-reasoning, think",
    "author": null,
    "author_email": "Chris Kilner <chris@rhiza.fr>",
    "download_url": "https://files.pythonhosted.org/packages/1b/41/3e9912eedc811673ae607666a8ea7e71db934e3c1617977e690b7aaa6692/ollama_think-0.1.4.tar.gz",
    "platform": null,
    "description": "# Ollama-Think Library\n\nA thin wrapper around the [ollama-python](https://github.com/ollama/ollama-python) library with the addition of caching, increased `think` model compatibility and a little syntax sugar.\n\n\n## Features\n\n- **Caching**: Automatically caches responses to significantly speed up repeated requests.\n- **Thinking**: Enables some officially unsupported models to use thinking mode. [Why hack?](why_hack.md)\n- **Streaming and Non-streaming**: Separates the underlying streaming and non-streaming interface to provide clean type hints.\n- **Syntax Sugar**: Less boiler-plate, so that you can maintain your flow.\n\n## Quickstart\n\nGet up and running in less than a minute.\n\n**1. Install the library:**\n\n```bash\npip install ollama-think\n```\n\n**2. Use:**\n\n```python\nfrom ollama_think import Client\n\n# Initialize the client\nclient = Client(host=\"http://localhost:11434\", cache_dir=\".ollama_cache\", clear_cache=False)\n\n# unpack the response into thinking and content\nthinking, content = client.call(\n    model=\"qwen3\",                 # or any other model\n    prompt=\"Why is the sky blue?\", # shortcut for messages=[{'role': 'user', 'content': 'Why is the sky blue?'}]\n    think=True                     # Set to True to see the model's thinking process\n)\n\nprint(f\"Thinking: {thinking}, Content: {content}\")\n```\n\n## Detailed Usage\n\n\n### Non-streaming\n\nThe `call` method provides strongly typed access to the underlying `Chat` method in non-streaming mode. It returns a `ThinkResponse` object which is a subclass of `ollama.ChatResponse` and adds some convenience properties. You can use `prompt` or `messages` as you prefer.\n\n```python\nfrom ollama_think import Client\nclient = Client()\n\n# Make a non-streaming call\nresponse: ThinkResponse = client.call(\n    model=\"qwen3\",         # The model to use\n    prompt=\"Hello, world!\" # A single user message\n    messages = None,       # or a list of messages\n    tools = None,          # A list of tools available\n    think = True,          # Enable thinking mode\n    format = None,         # The format to return a response in: None | 'json' | your_obj.model_json_schema()\n    options = None,        # Additional model parameter dict, such as {'temperature': 0.1, 'num_ctx': 8192}\n    keep_alive = None,     # Controls how long the model will stay loaded in memory following the request.\n    use_cache = True)      # If True, attempts to retrieve the response from cache.\n\n# The response object contains all the original data from the Ollama ChatResponse\nprint(response)\n# ThinkResponse(\n#     model='qwen3',\n#     created_at='2025-07-03T14:16:05.8452406Z',\n#     done=True,\n#     done_reason='stop',\n#     total_duration=2461619200,\n#     load_duration=2111438400,\n#     prompt_eval_count=20,\n#     prompt_eval_duration=78409600,\n#     eval_count=16,\n#     eval_duration=271104600,\n#     message=Message(role='assistant', content='Hello, world! How can I assist you today?', thinking='...',\n#                     images=None, tool_calls=None))\n\n# For convenience, you can access the content and thinking as properties\nprint(response.thinking)\n# '...'\nprint(response.content)\n# 'Hello, world! ...'\n\n# The response object can be used as a string which will show just the 'content'\nprint(f\"The model said: {response}\")  # same as response.content\n# The model said: Hello, world! ...\n\n# or unpack the response into thinking and content for single line access\nthinking, content = response\nprint(f\"Thinking: {thinking}, Content: {content}\")\n```\n\n### Streaming\n\nThe `stream` method provides a strongly typed access to the underlying `Chat` method in streaming mode. It returns a an iterator of `ThinkResponse` chunks\n\n```python\nfrom ollama_think import Client\nclient = Client()\n\nstream = client.stream(model=\"qwen3\", prompt=\"Tell me a short story about italian chimpanzees and bananas\", think=True)\nfor thinking, content in stream:\n    print(thinking, end=\"\")\n    print(content, end=\"\")  # empty until thinking is finished for most models\n```\n\n### Thinking Mode\n\nThe `think` parameter tells ollama to enable thinking for models that support this. For other models that use non-standard ways of enabling thinking we do the neccesary. [Why hack?](why_hack.md) Default config: [src/ollama_think/config.yaml](src/ollama_think/config.yaml) Results: [model_capabilities.md](model_capabilities.md)\n\nSome models will think, even without 'enabling' thinking. This output is separated out of the `content` into `thinking`\n\nNote: Not all models officially or unofficially support thinking. They will throw a `400` error if you try to enable thinking.\n\n\n### Caching\n\nThe client automatically caches responses using the light-weight `DiskCache` library to avoid re-generating them for the same request. You can disable this behavior by setting `use_cache=False`.\n\n```python\n# This call will be cached\nresponse1 = client.call(model=\"qwen3\", prompt=\"Hello, world!\") # 0.31 seconds\n\n# This call will use the cached response\nresponse2 = client.call(model=\"qwen3\", prompt=\"Hello, world!\") # 0.0001 seconds\n\n# This call will not attempt to get from the cache and will not store the result\nresponse3 = client.call(model=\"qwen3\", prompt=\"Hello, world!\", use_cache=False)\n```\n\nYou can clear the cache by passing `clear_cache=True` when initializing the client:\n\n```python\nclient = Client(clear_cache=True)\n```\n\n### Options\n\nThe `options` parameter of the underlying `chat` method can be used to change how the model\nresponds. The most commonly used parameters are\n\n- `temperature` Low values keep the model deterministic, Higher values for more creativity Typically 0.1 -> 1.0\n- `num_ctx` Ollama has a default context length of 2048, which can be increased if you have enough VRAM. If you send in more\nthan `num_ctx` tokens, ollama will silently truncate your message, which can lead to lost instructions.\n\n```python\nfrom ollama_think import Client\nclient = Client()\n\nprompt=\"Describe the earth to an alien who has just arrived.\"\noptions={'num_ctx': 8192, 'temperature': 0.9}\n\nprint(\"Using prompt:\", prompt)\nprint(\"Using options:\", options)\n\nthinking, content = client.call(model=\"qwen3\", prompt=prompt, think=True, options=options)\nprint(f\"Thinking: {thinking}, Content: {content}\")\n```\n\nSee [examples/options_example.py](examples/options_example.py) for a full list of options\n\n### Tool Calling\n\nBefore, and underneath the concept of MCP servers are the humble tool_calls. By telling the model that you have a tool available,\nthe model can choose to reply with a special format that indicates that it wants to call a tool. Typically, this call is\nintercepted, the tool is excecuted and the result sent back to the model. The model's second response can then be shown to a user.\n\nSee [examples/tool_calling_example.py](examples/tool_calling_example.py)\n\n### Response Formats\n\nForcing JSON format can encourage some models to behave. It is usualy a good idea to mention JSON in the prompt.\n\n```python\nfrom ollama_think import Client\nimport json\n\nclient = Client()\n\ntext_json = client.call(\n    model=\"qwen3\",\n    prompt=\"Design a json representation of a spiral galaxy\",\n    format=\"json\",\n).content\n\nmy_object = json.loads(text_json)  # might explode if invalid json was returned\n```\n\nYou can use pydantic models to describe more exactly the format you want.\n\n```python\nfrom ollama_think import Client\nfrom pydantic import BaseModel, Field\nclient = Client()\n\nclass Heat(BaseModel):\n    \"\"\"A specially crafted response object to capture an iterpretation of heat\"\"\"\n    reaoning: str = Field(..., description=\"your reasoning for the response\")\n    average_temperature: float = Field(..., description=\"average temperature\")\n\ntext_obj = client.call(model=\"qwen3\", prompt=\"How hot is the world?\",\n        format=Heat.model_json_schema()).content\n\nmy_obj = Heat.model_validate_json(text_obj) # might explode it the format is invalid\n```\n\nSee [examples/response_format_example.py](examples/response_format_example.py)\n\n### Access to the underlying ollama client\n\nSince the `ollama_think` is a thin wrapper around the `ollama.client`, you can still access the all the underlying ollama client methods.\n\n```python\nfrom ollama_think import Client\nfrom ollama import ChatResponse\n\nclient = Client()\nresponse: ChatResponse = client.chat(model='llama3.2', messages=[\n  {\n    'role': 'user',\n    'content': 'Why is the sky blue?',\n  },\n])\nprint(response['message']['content'])\n```\n\n### Prompts and Messages\n\n```python\nfrom ollama_think import Client\n\nclient = Client()\n# the prompt parameter in `call` and `stream` is just a shortcut for\nprompt = 'Why is the sky blue?'\nmessage =  {'role': 'user', 'content': prompt}\nclient.call(model='llama3.2', messages=[message])  # shortcut\nclient.call(model='llama3.2', prompt=prompt)       # same thing\n```\n\n## Credit to\n\n- ollama [https://ollama.com/](https://ollama.com/)\n- ollama-python [https://github.com/ollama/ollama-python](https://github.com/ollama/ollama-python)\n- diskcache [https://github.com/grantjenks/python-diskcache/](https://github.com/grantjenks/python-diskcache/)\n- pydantic [https://pydantic-docs.helpmanual.io/](https://pydantic-docs.helpmanual.io/)\n\n## Reference docs\n\n- Ollama Thinking - [https://ollama.com/blog/thinking](https://ollama.com/blog/thinking)\n- Ollama Tool support - [https://ollama.com/blog/tool-support](https://ollama.com/blog/tool-support)\n- Ollama Structured Outputs - [https://ollama.com/blog/structured-outputs](https://ollama.com/blog/structured-outputs)\n- Ollama Options - [https://github.com/ollama/ollama-python/blob/main/ollama/_types.py](https://github.com/ollama/ollama-python/blob/main/ollama/_types.py)\n\n## Contributing\n\nContributions are welcome! Please open an issue or submit a pull request.\n\n### Development Setup\n\nThis project uses `uv` for package management and `hatch` for task running.\n\n1.  **Clone the repository:**\n    ```bash\n    git clone https://github.com/your-username/ollama-think.git\n    cd ollama-think\n    ```\n\n2.  **Create a virtual environment and install dependencies:**\n    This command creates a virtual environment in `.venv` and installs all dependencies, including development tools.\n    ```bash\n    uv sync --extra dev\n    ```\n\n### Running Checks\n\n- **Linting and Formatting:**\n  To automatically format and lint the code, run:\n  ```bash\n  uv run ruff format .\n  uv run ruff check . --fix\n  ```\n\n- **Running Tests:**\n  - To run the default (fast) unit tests:\n    ```bash\n    uv run hatch test\n    # or more simply\n    uv run pytest\n    ```\n  - To run the full test suite, including `slow` integration tests that require a running Ollama instance:\n    ```bash\n    uv run hatch test:run -m \"slow or not slow\"\n    ```\n  - To pass a custom host to the integration tests:\n    ```bash\n    uv run hatch test:run -m \"slow or not slow\" --host http://localhost:11434\n    ```\n\n\n- **Testing new models:**\n\n  ```python\n  # edit /src/ollama_think/config.yaml\n  # check the output from non-streaming and streaming\n  uv run ./tests/test_hacks.py --host http://localhost:11434 --model \"model_name\"\n\n  # check that this makes a difference\n  uv run pytest ./tests/test_model_capabilities.py --host http://localhost:11434 -m \"slow\" --model \"model_name\"\n\n  # re-generate doc\n  uv run tests/generate_model_capabilities_report.py\n\n  # submit a PR\n  ```\n \n## License\n\nThis project is licensed under the MIT License.\n",
    "bugtrack_url": null,
    "license": null,
    "summary": "A light wrapper around ollama-python that introduces caching, syntax sugar and increased `think` compatibility",
    "version": "0.1.4",
    "project_urls": {
        "Bug Tracker": "https://github.com/rhiza-fr/ollama-think/issues",
        "Homepage": "https://github.com/rhiza-fr/ollama-think"
    },
    "split_keywords": [
        "ai",
        " llm",
        " cogito",
        " compatibility",
        " granite",
        " ollama",
        " phi4-mini-reasoning",
        " phi4-reasoning",
        " think"
    ],
    "urls": [
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "693ad29a3a273bffb0b86cbbb24f2a77272e27b034fc8ebc074c18c82863bc69",
                "md5": "e0736ac591a40d7aad3ec29fc9279426",
                "sha256": "610cfd15c27ec54f19f717035f0ec67885537b575566c2bcfe4785f4995fc241"
            },
            "downloads": -1,
            "filename": "ollama_think-0.1.4-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "e0736ac591a40d7aad3ec29fc9279426",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.9",
            "size": 18907,
            "upload_time": "2025-07-09T08:26:51",
            "upload_time_iso_8601": "2025-07-09T08:26:51.586071Z",
            "url": "https://files.pythonhosted.org/packages/69/3a/d29a3a273bffb0b86cbbb24f2a77272e27b034fc8ebc074c18c82863bc69/ollama_think-0.1.4-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "1b413e9912eedc811673ae607666a8ea7e71db934e3c1617977e690b7aaa6692",
                "md5": "dac3e80d4fda3264b132301fc318359f",
                "sha256": "e19ff01aaba4035008b626d17d040b3c720f06e099acb247ef25f71f032d8858"
            },
            "downloads": -1,
            "filename": "ollama_think-0.1.4.tar.gz",
            "has_sig": false,
            "md5_digest": "dac3e80d4fda3264b132301fc318359f",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.9",
            "size": 98676,
            "upload_time": "2025-07-09T08:26:53",
            "upload_time_iso_8601": "2025-07-09T08:26:53.231445Z",
            "url": "https://files.pythonhosted.org/packages/1b/41/3e9912eedc811673ae607666a8ea7e71db934e3c1617977e690b7aaa6692/ollama_think-0.1.4.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2025-07-09 08:26:53",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "rhiza-fr",
    "github_project": "ollama-think",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": true,
    "requirements": [
        {
            "name": "annotated-types",
            "specs": [
                [
                    "==",
                    "0.7.0"
                ]
            ]
        },
        {
            "name": "anyio",
            "specs": [
                [
                    "==",
                    "4.9.0"
                ]
            ]
        },
        {
            "name": "certifi",
            "specs": [
                [
                    "==",
                    "2025.6.15"
                ]
            ]
        },
        {
            "name": "click",
            "specs": [
                [
                    "==",
                    "8.2.1"
                ]
            ]
        },
        {
            "name": "colorama",
            "specs": [
                [
                    "==",
                    "0.4.6"
                ]
            ]
        },
        {
            "name": "coverage",
            "specs": [
                [
                    "==",
                    "7.9.2"
                ]
            ]
        },
        {
            "name": "diskcache",
            "specs": [
                [
                    "==",
                    "5.6.3"
                ]
            ]
        },
        {
            "name": "h11",
            "specs": [
                [
                    "==",
                    "0.16.0"
                ]
            ]
        },
        {
            "name": "httpcore",
            "specs": [
                [
                    "==",
                    "1.0.9"
                ]
            ]
        },
        {
            "name": "httpx",
            "specs": [
                [
                    "==",
                    "0.28.1"
                ]
            ]
        },
        {
            "name": "idna",
            "specs": [
                [
                    "==",
                    "3.10"
                ]
            ]
        },
        {
            "name": "iniconfig",
            "specs": [
                [
                    "==",
                    "2.1.0"
                ]
            ]
        },
        {
            "name": "markdown-it-py",
            "specs": [
                [
                    "==",
                    "3.0.0"
                ]
            ]
        },
        {
            "name": "mdurl",
            "specs": [
                [
                    "==",
                    "0.1.2"
                ]
            ]
        },
        {
            "name": "ollama",
            "specs": [
                [
                    "==",
                    "0.5.1"
                ]
            ]
        },
        {
            "name": "packaging",
            "specs": [
                [
                    "==",
                    "25.0"
                ]
            ]
        },
        {
            "name": "pluggy",
            "specs": [
                [
                    "==",
                    "1.6.0"
                ]
            ]
        },
        {
            "name": "pydantic",
            "specs": [
                [
                    "==",
                    "2.11.7"
                ]
            ]
        },
        {
            "name": "pydantic-core",
            "specs": [
                [
                    "==",
                    "2.33.2"
                ]
            ]
        },
        {
            "name": "pygments",
            "specs": [
                [
                    "==",
                    "2.19.2"
                ]
            ]
        },
        {
            "name": "pytest",
            "specs": [
                [
                    "==",
                    "8.4.1"
                ]
            ]
        },
        {
            "name": "pytest-cov",
            "specs": [
                [
                    "==",
                    "6.2.1"
                ]
            ]
        },
        {
            "name": "pytest-mock",
            "specs": [
                [
                    "==",
                    "3.14.1"
                ]
            ]
        },
        {
            "name": "pyyaml",
            "specs": [
                [
                    "==",
                    "6.0.2"
                ]
            ]
        },
        {
            "name": "rich",
            "specs": [
                [
                    "==",
                    "14.0.0"
                ]
            ]
        },
        {
            "name": "ruff",
            "specs": [
                [
                    "==",
                    "0.12.2"
                ]
            ]
        },
        {
            "name": "shellingham",
            "specs": [
                [
                    "==",
                    "1.5.4"
                ]
            ]
        },
        {
            "name": "sniffio",
            "specs": [
                [
                    "==",
                    "1.3.1"
                ]
            ]
        },
        {
            "name": "typer",
            "specs": [
                [
                    "==",
                    "0.16.0"
                ]
            ]
        },
        {
            "name": "typing-extensions",
            "specs": [
                [
                    "==",
                    "4.14.1"
                ]
            ]
        },
        {
            "name": "typing-inspection",
            "specs": [
                [
                    "==",
                    "0.4.1"
                ]
            ]
        }
    ],
    "lcname": "ollama-think"
}
        
Elapsed time: 1.56006s