Metadata-Version: 2.1
Name: jina
Version: 3.9.3
Summary: Build cross-modal and multi-modal applications on the cloud · Neural Search · Creative AI · Cloud Native · MLOps
Home-page: https://github.com/jina-ai/jina/
Author: Jina AI
Author-email: hello@jina.ai
License: Apache 2.0
Download-URL: https://github.com/jina-ai/jina/tags
Project-URL: Documentation, https://docs.jina.ai
Project-URL: Source, https://github.com/jina-ai/jina/
Project-URL: Tracker, https://github.com/jina-ai/jina/issues
Description: <p align="center">
        <br><br><br>
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/docs/_static/logo-light.svg?raw=true" alt="Jina logo: Build cross-modal and multi-modal applications on the cloud · Neural Search · Creative AI · Cloud Native" width="150px"></a>
        <br><br><br>
        </p>
        
        <p align="center">
        <b>Build cross-modal and multi-modal applications<sup><a href="https://docs.jina.ai/get-started/what-is-cross-modal-multi-modal/">[?]</a></sup> on the cloud</b>
        </p>
        
        
        <p align=center>
        <a href="https://pypi.org/project/jina/"><img alt="PyPI" src="https://img.shields.io/pypi/v/jina?label=Release&style=flat-square"></a>
        <a href="https://codecov.io/gh/jina-ai/jina"><img alt="Codecov branch" src="https://img.shields.io/codecov/c/github/jina-ai/jina/master?&logo=Codecov&logoColor=white&style=flat-square"></a>
        <a href="https://slack.jina.ai"><img src="https://img.shields.io/badge/Slack-3.6k-blueviolet?logo=slack&amp;logoColor=white&style=flat-square"></a>
        <a href="https://pypistats.org/packages/jina"><img alt="PyPI - Downloads from official pypistats" src="https://img.shields.io/pypi/dm/jina?style=flat-square"></a>
        <a href="https://github.com/jina-ai/jina/actions/workflows/cd.yml"><img alt="Github CD status" src="https://github.com/jina-ai/jina/actions/workflows/cd.yml/badge.svg"></a>
        </p>
        
        <!-- start jina-description -->
        
        Jina is a MLOps framework that empowers anyone to build cross-modal and multi-modal applications on the cloud. It uplifts a PoC into a production-ready service. Jina handles the infrastructure complexity, making advanced solution engineering and cloud-native technologies accessible to every developer. 
        
        Applications built with Jina enjoy the following features out-of-the-box:
        
        🌌 **Universal**
          - Build applications that deliver fresh insights from multiple data types such as text, image, audio, video, 3D mesh, PDF with [Jina AI's DocArray](https://docarray.jina.ai).
          - Support all mainstream deep learning frameworks.
          - Polyglot gateway that supports gRPC, Websockets, HTTP, GraphQL protocols with TLS.
        
        ⚡ **Performance**
          - Intuitive design pattern for high-performance microservices.
          - Scaling at ease: set replicas, sharding in one line. 
          - Duplex streaming between client and server.
          - Async and non-blocking data processing over dynamic flows.
        
        ☁️ **Cloud-native**
          - Seamless Docker container integration: sharing, exploring, sandboxing, versioning and dependency control via [Jina Hub](https://hub.jina.ai).
          - Full observability via Prometheus and Grafana.
          - Fast deployment to Kubernetes, Docker Compose.
        
        🍱 **Ecosystem**
          - Improved engineering efficiency thanks to the Jina AI ecosystem, so you can focus on innovating with the data applications you build.
          - Free CPU/GPU hosting via [Jina Cloud](https://docs.jina.ai/fundamentals/jcloud/).
        
        
        <p align="center">
        <a href="#"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/core-tree-graph.svg?raw=true" alt="Jina in Jina AI neural search ecosystem" width="100%"></a>
        </p>
        
        <!-- end jina-description -->
        
        
        ## [Documentation](https://docs.jina.ai)
        
        <table align=center>
        <thead>
          <tr>
            <th colspan="4">Understand Jina better</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><a href="https://docs.jina.ai/get-started/what-is-jina/" target="_blank" rel="noopener noreferrer">📗 What is Jina?</a></td>
            <td><a href="https://docs.jina.ai/get-started/what-is-jina/#relation-to-mlops" target="_blank" rel="noopener noreferrer">🔍 Is Jina MLOps for search?</a></td>
            <td><a href="https://docs.jina.ai/get-started/comparing-alternatives/" target="_blank" rel="noopener noreferrer">🆚 How Jina compares to alternatives?</a></td>
            <td><a href="https://docs.jina.ai/get-started/what-is-jina/#why-cloud-native" target="_blank" rel="noopener noreferrer">☁️ What is Cloud-Native?</a></td>
          </tr>
          <tr>
            <td><a href="https://docs.jina.ai/get-started/what-is-cross-modal-multi-modal/" target="_blank" rel="noopener noreferrer">🔮 What is cross-modal and multimodal？</a></td>
            <td><a href="https://docs.jina.ai/get-started/what-is-cross-modal-multi-modal/#neural-search" target="_blank" rel="noopener noreferrer">🧬 What is neural search?</a></td>
            <td><a href="https://docs.jina.ai/get-started/what-is-cross-modal-multi-modal/#creative-ai" target="_blank" rel="noopener noreferrer">🎨 What is creative AI?</a></td>
            <td></td>
          </tr>
        </tbody>
        </table>
        
        
        ## Install 
        
        ```bash
        pip install jina
        ```
        
        [More install options on Apple Silicon and Windows can be found here](https://docs.jina.ai/get-started/install/).
        
        
        ## Get Started
        
        
        ### Basic Concepts
        
        Document, Executor and Flow are three fundamental concepts in Jina.
        
        - [**Document**](https://docarray.jina.ai/) is the fundamental data structure.
        - [**Executor**](https://docs.jina.ai/fundamentals/executor/) is a Python class with functions that use Documents as IO.
        - [**Flow**](https://docs.jina.ai/fundamentals/flow/) ties Executors together into a pipeline and exposes it with an API gateway.
        
        [The full glossary is explained here.](https://docs.jina.ai/fundamentals/architecture-overview/)
        
        
        ---
        
        <p align="center">
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/streamline-banner.png?raw=true" alt="Jina: Streamline AI & ML Product Delivery" width="100%"></a>
        </p>
        
        ### Streamline AI & ML Product Delivery
        
        A new project starts from local. With Jina, you can easily leverage existing deep learning stacks, improve the quality and quickly build the POC.
        
        ```python
        import torch
        from jina import DocumentArray
        
        model = torch.nn.Sequential(
            torch.nn.Linear(
                in_features=128,
                out_features=128,
            ),
            torch.nn.ReLU(),
            torch.nn.Linear(in_features=128, out_features=32),
        )
        
        
        docs = DocumentArray.from_files('left/*.jpg')
        docs.embed(model)
        ```
        
        Moving to production, Jina enhances the POC with service endpoint, scalability and adds cloud-native features, making it ready for production without refactoring.
        
        <table>
        <tr>
        <td>
        
        ```python
        from jina import DocumentArray, Executor, requests
        from .embedding import model
        
        
        class MyExec(Executor):
            @requests(on='/embed')
            async def embed(self, docs: DocumentArray, **kwargs):
                docs.embed(model)
        ```
        
        </td>
        <td>
            
        ```yaml
        jtype: Flow
        with:
          port: 12345
        executors:
        - uses: MyExec
          replicas: 2
        ```
        </td>
        </tr>
        </table>
        
        
        Finally, the project can be easily deployed to the cloud and serve real traffic.
        
        ```bash
        jina cloud deploy ./
        ```
        
        ---
        
        <p align="center">
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/no-complexity-banner.png?raw=true" alt="Jina: No Infrastructure Complexity, High Engineering Efficiency" width="100%"></a>
        </p>
        
        ### Hello world example
        
        Leveraging these three concepts, let's look at a simple example below:
        
        ```python
        from jina import DocumentArray, Executor, Flow, requests
        
        
        class MyExec(Executor):
            @requests
            async def add_text(self, docs: DocumentArray, **kwargs):
                for d in docs:
                    d.text += 'hello, world!'
        
        
        f = Flow().add(uses=MyExec).add(uses=MyExec)
        
        with f:
            r = f.post('/', DocumentArray.empty(2))
            print(r.texts)
        ```
        
        - The first line imports three concepts we just introduced;
        - `MyExec` defines an async function `add_text` that receives `DocumentArray` from network requests and appends `"hello, world"` to `.text`;
        - `f` defines a Flow streamlined two Executors in a chain;
        - The `with` block opens the Flow, sends an empty DocumentArray to the Flow, and prints the result.
        
        Running it gives you:
        
        <p align="center">
        <a href="#"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/run-hello-world.gif?raw=true" alt="Running a simple hello-world program" width="70%"></a>
        </p>
        
        At the last line we see its output `['hello, world!hello, world!', 'hello, world!hello, world!']`.
        
        
        While one could use standard Python with the same number of lines and get the same output, Jina accelerates time to market of your application by making it more scalable and cloud-native. Jina also handles the infrastructure complexity in production and other Day-2 operations so that you can focus on the data application itself.  
        
        ---
        
        <p align="center">
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/scalability-banner.png?raw=true" alt="Jina: Scalability and concurrency at ease" width="100%"></a>
        </p>
        
        ### Scalability and concurrency at ease
        
        The example above can be refactored into a Python Executor file and a Flow YAML file:
        
        <table>
        <tr>
        <th> <code>toy.yml</code> </th> 
        <th> executor.py </th>
        </tr>
        <tr>
        <td> 
        
        ```yaml
        jtype: Flow
        with:
          port: 51000
          protocol: grpc
        executors:
        - uses: MyExec
          name: foo
          py_modules:
            - executor.py
        - uses: MyExec
          name: bar
          py_modules:
            - executor.py
        ```
             
        </td>
        <td>
        
        ```python
        from jina import DocumentArray, Executor, requests
        
        
        class MyExec(Executor):
            @requests
            async def add_text(self, docs: DocumentArray, **kwargs):
                for d in docs:
                    d.text += 'hello, world!'
        ```
        
        </td>
        </tr>
        </table>
        
        
        Run the following command in the terminal:
        
        ```bash
        jina flow --uses toy.yml
        ```
        
        <p align="center">
        <a href="#"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/flow-block.png?raw=true" alt="Running a simple hello-world program" width="50%"></a>
        </p>
        
        The server is successfully started, and you can now use a client to query it.
        
        ```python
        from jina import Client, Document
        
        c = Client(host='grpc://0.0.0.0:51000')
        c.post('/', Document())
        ```
        
        This simple refactoring allows developers to write an application in the client-server style. The separation of Flow YAML and Executor Python file does not only make the project more maintainable but also brings scalability and concurrency to the next level:
        - The data flow on the server is non-blocking and async. New request is handled immediately when an Executor is free, regardless if previous request is still being processed.
        - Scalability can be easily achieved by the keywords `replicas` and `needs` in YAML/Python. Load-balancing is automatically added when necessary to ensure the maximum throughput.
        
        <table>
        <tr>
        <th> <code>toy.yml</code> </th> 
        <th> Flowchart </th>
        </tr>
        <tr>
        <td> 
        
        ```yaml
        jtype: Flow
        with:
          port: 51000
          protocol: grpc
        executors:
        - uses: MyExec
          name: foo
          py_modules:
            - executor.py
          replicas: 2
        - uses: MyExec
          name: bar
          py_modules:
            - executor.py
          replicas: 3
          needs: gateway
        - needs: [foo, bar]
          name: baz
        ```
             
        </td>
        <td>
        
        <p align="center">
        <a href="#"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/scale-flow.svg?raw=true" alt="Running a simple hello-world program" width="70%"></a>
        </p>
        
        </td>
        </tr>
        </table>
        
        - You now have an API gateway that supports gRPC (default), Websockets, and HTTP protocols with TLS.
        - The communication between clients and the API gateway is duplex.
        - The API gateway allows you to route request to a specific Executor while other parts of the Flow are still busy, via `.post(..., target_executor=...)`
        
        ---
        
        <p align="center">
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/container-banner.png?raw=true" alt="Jina: Seamless Container Integration" width="100%"></a>
        </p>
        
        ### Seamless Container integration
        
        Without having to worry about dependencies, you can easily share your Executors with others; or use public/private Executors in your project thanks to [Jina Hub](https://hub.jina.ai).
        
        To create an Executor:
        
        ```bash
        jina hub new 
        ```
        
        To push it to Jina Hub:
        
        ```bash
        jina hub push .
        ```
        
        To use a Hub Executor in your Flow:
        
        |        | Docker container                           | Sandbox                                     | Source                              |
        |--------|--------------------------------------------|---------------------------------------------|-------------------------------------|
        | YAML   | `uses: jinahub+docker://MyExecutor`        | `uses: jinahub+sandbox://MyExecutor`        | `uses: jinahub://MyExecutor`        |
        | Python | `.add(uses='jinahub+docker://MyExecutor')` | `.add(uses='jinahub+sandbox://MyExecutor')` | `.add(uses='jinahub://MyExecutor')` |
        
        Behind this smooth experience is advanced management of Executors:
        - Automated builds on the cloud
        - Store, deploy, and deliver Executors cost-efficiently;
        - Automatically resolve version conflicts and dependencies;
        - Instant delivery of any Executor via Sandbox without pulling anything to local.
        
        ---
        
        <p align="center">
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/cloud-native-banner.png?raw=true" alt="Jina: Seamless Container Integration" width="100%"></a>
        </p>
        
        ### Fast-lane to cloud-native
        
        Using Kubernetes becomes easy:
        
        ```bash
        jina export kubernetes flow.yml ./my-k8s
        kubectl apply -R -f my-k8s
        ```
        
        Using Docker Compose becomes easy:
        
        ```bash
        jina export docker-compose flow.yml docker-compose.yml
        docker-compose up
        ```
        
        Using Prometheus becomes easy:
        
        ```python
        from jina import Executor, requests, DocumentArray
        
        
        class MyExec(Executor):
            @requests
            def encode(self, docs: DocumentArray, **kwargs):
                with self.monitor('preprocessing_seconds', 'Time preprocessing the requests'):
                    docs.tensors = preprocessing(docs)
                with self.monitor(
                    'model_inference_seconds', 'Time doing inference the requests'
                ):
                    docs.embedding = model_inference(docs.tensors)
        ```
        
        Using Grafana becomes easy, just [download this JSON](https://github.com/jina-ai/example-grafana-prometheus/blob/main/grafana-dashboards/flow.json) and import it into Grafana:
        
        <p align="center">
        <a href="https://docs.jina.ai"><img src="https://github.com/jina-ai/jina/blob/master/.github/readme/grafana.png?raw=true" alt="Jina: Seamless Container Integration" width="70%"></a>
        </p>
        
        
        What cloud-native technology is still challenging to you? [Tell us](https://github.com/jina-ai/jina/issues), we will handle the complexity and make it easy for you.
        
        <!-- start support-pitch -->
        
        ## Support
        
        - Join our [Slack community](https://slack.jina.ai) and chat with other community members about ideas.
        - Join our [Engineering All Hands](https://youtube.com/playlist?list=PL3UBBWOUVhFYRUa_gpYYKBqEAkO4sxmne) meet-up to discuss your use case and learn Jina's new features.
            - **When?** The second Tuesday of every month
            - **Where?**
              Zoom ([see our public events calendar](https://calendar.google.com/calendar/embed?src=c_1t5ogfp2d45v8fit981j08mcm4%40group.calendar.google.com&ctz=Europe%2FBerlin)/[.ical](https://calendar.google.com/calendar/ical/c_1t5ogfp2d45v8fit981j08mcm4%40group.calendar.google.com/public/basic.ics))
              and [live stream on YouTube](https://youtube.com/c/jina-ai)
        - Subscribe to the latest video tutorials on our [YouTube channel](https://youtube.com/c/jina-ai)
        
        ## Join Us
        
        Jina is backed by [Jina AI](https://jina.ai) and licensed under [Apache-2.0](./LICENSE).
        [We are actively hiring](https://jobs.jina.ai) AI engineers, solution engineers to build the next neural search ecosystem in open source.
        
        <!-- end support-pitch -->
        
Keywords: jina cloud-native cross-modal multi-modal neural-search query search index elastic neural-network encoding embedding serving docker container image video audio deep-learning mlops
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Unix Shell
Classifier: Environment :: Console
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Database :: Database Engines/Servers
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
Classifier: Topic :: Scientific/Engineering :: Image Recognition
Classifier: Topic :: Multimedia :: Video
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Topic :: Software Development
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Description-Content-Type: text/markdown
Provides-Extra: core
Provides-Extra: numpy
Provides-Extra: protobuf
Provides-Extra: grpcio
Provides-Extra: grpcio-reflection
Provides-Extra: grpcio-health-checking
Provides-Extra: pyyaml
Provides-Extra: packaging
Provides-Extra: docarray
Provides-Extra: jina-hubble-sdk
Provides-Extra: jcloud
Provides-Extra: devel
Provides-Extra: perf
Provides-Extra: uvloop
Provides-Extra: standard
Provides-Extra: prometheus_client
Provides-Extra: fastapi
Provides-Extra: uvicorn[standard]
Provides-Extra: docarray[common]
Provides-Extra: docker
Provides-Extra: pathspec
Provides-Extra: cryptography
Provides-Extra: filelock
Provides-Extra: requests
Provides-Extra: websockets
Provides-Extra: pydantic
Provides-Extra: python-multipart
Provides-Extra: aiofiles
Provides-Extra: aiohttp
Provides-Extra: aiostream
Provides-Extra: scipy
Provides-Extra: test
Provides-Extra: Pillow
Provides-Extra: pytest
Provides-Extra: pytest-timeout
Provides-Extra: pytest-mock
Provides-Extra: pytest-cov
Provides-Extra: coverage
Provides-Extra: pytest-repeat
Provides-Extra: pytest-asyncio
Provides-Extra: pytest-reraise
Provides-Extra: flaky
Provides-Extra: mock
Provides-Extra: requests-mock
Provides-Extra: pytest-custom_exit_code
Provides-Extra: black
Provides-Extra: kubernetes
Provides-Extra: pytest-kind
Provides-Extra: pytest-lazy-fixture
Provides-Extra: cicd
Provides-Extra: torch
Provides-Extra: psutil
Provides-Extra: strawberry-graphql
Provides-Extra: sgqlc
Provides-Extra: bs4
Provides-Extra: jsonschema
Provides-Extra: portforward
Provides-Extra: tensorflow
Provides-Extra: all
